为什么使用抽象基类在Python

抽象方法是基类中定义的方法，但却没有任何实现。在java中，可以把方法申明成一个接口。而在python中实现一个抽象方法的简单的方法是：

龙湾网站建设公司创新互联,龙湾网站设计制作，有大型网站制作公司丰富经验。已为龙湾近千家提供企业网站建设服务。企业网站搭建\成都外贸网站建设要多少钱，请找那个售后服务好的龙湾做网站的公司定做！

class Sheep（object）：

def get_size(self):

raise NotImplementedError

任何从Sheep继承下来的子类必须实现get_size方法。否则就会产生一个错误。但这种实现方法有个缺点。定义的子类只有调用那个方法时才会抛错。这里有个简单方法可以在类被实例化后触发它。使用python提供的abc模块。

python中定义函数的关键字是什么?

python中定义函数的关键字是def。

Python使用def关键字开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的具体功能实现代码，如果想要函数有返回值, 在expressions中的逻辑代码中用return返回。

上面我们定义了一个名字为 function 的函数，函数没有不接受参数，所以括号内部为空，紧接着就是 函数的功能代码。

如果执行该脚本，发现并没有输出任何输出，因为我们只定义了函数，而并没有执行函数。 这时我们在Python命令提示符中输入函数调用 function(), 注意这里调用函数的括号不能省略。

python的学习

如果我们用代码实现了一个小功能，但想要在程序代码中重复使用，不能在代码中到处粘贴这些代码，因为这样做违反了软件工程中DRY原则。 Python提供了函数功能，可以将我们这部分功能抽象成一个函数以方便程序调用，或者提供给其他模块使用。

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。（推荐学习：Python视频教程）函数必须先定义，才能调用，否则会报错，无参数时函数的调用函数名()。

有参数时函数的调，不要在定义函数的时候在函数体里面调用本身，否则会出不来，陷入循环调用，函数需要调用函数体才会被执行，单纯的只是定义函数是不会被执行的。

Python中的抽象类和抽象方法

抽象类是一个特殊的类，它只能被继承，不能被实例化。python中如果要使用抽象类则需要导入模块 abc ,

在定义抽象类的时候，需要添加参数 metaclass=abc.ABCMeta ,在定义抽象方法时需要在方法前添加声明

注意，我们只需写出方法的名称，不用写出具体的方法内容。

例如：

或者我们也可以写成

python下的抽象类的用途和意义？

抽象类是不完整的，并且它只能用作基类。它与非抽象类的不同： 1、抽象类不能直接实例化，并且对抽象类使用 new 运算符是编译时错误。虽然一些变量和值在编译时的类型可以是抽象的，但是这样的变量和值必须或者为 null，或者含有对非抽象类的实例的引用（此非抽象类是从抽象类派生的）。 2、允许（但不要求）抽象类包含抽象成员。 3、抽象类不能被密封。 当从抽象类派生非抽象类时，这些非抽象类必须具体实现所继承的所有抽象成员，从而重写那些抽象成员。在下边的示例中： abstract class A{ public abstract void F();} abstract class B: A{ public void G() {}} class C: B{ public override void F() { // actual implementation of F }} 　抽象类 A 引入抽象方法 F。类 B 引入另一个方法 G，但由于它不提供 F 的实现，B 也必须声明为抽象类。类 C 重写 F，并提供一个具体实现。由于 C 中没有了抽象成员，因此可以（但并非必须）将 C 声明为非抽象类。 抽象类与接口紧密相关。然接口又比抽象类更抽象，这主要体现在它们的差别上：1）类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。2）抽象类当中可以存在非抽象的方法，可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3）抽象类中的成员变量可以被不同的修饰符来修饰，可接口中的成员变量默认的都是静态常量（static final）。4）这一点也是最重要的一点本质的一点"抽象类是对象的抽象，然而接口是一种行为规范"。

如何在Python中使用static，class，abstract方法

方法在Python中是如何工作的

方法就是一个函数，它作为一个类属性而存在，你可以用如下方式来声明、访问一个函数：

Python

1

2

3

4

5

6

7

8

class Pizza(object):

...     def __init__(self, size):

...         self.size = size

...     def get_size(self):

...         return self.size

...

Pizza.get_size

unbound method Pizza.get_size

Python在告诉你，属性_get_size是类Pizza的一个未绑定方法。这是什么意思呢？很快我们就会知道答案：

Python

1

2

3

4

Pizza.get_size()

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

我们不能这么调用，因为它还没有绑定到Pizza类的任何实例上，它需要一个实例作为第一个参数传递进去（Python2必须是该类的实例，Python3中可以是任何东西），尝试一下：

Python

1

2

Pizza.get_size(Pizza(42))

42

太棒了，现在用一个实例作为它的的第一个参数来调用，整个世界都清静了，如果我说这种调用方式还不是最方便的，你也会这么认为的；没错，现在每次调用这个方法的时候我们都不得不引用这个类，如果不知道哪个类是我们的对象，长期看来这种方式是行不通的。

那么Python为我们做了什么呢，它绑定了所有来自类_Pizza的方法以及该类的任何一个实例的方法。也就意味着现在属性get_size是Pizza的一个实例对象的绑定方法，这个方法的第一个参数就是该实例本身。

Python

1

2

3

4

Pizza(42).get_size

bound method Pizza.get_size of __main__.Pizza object at 0x7f3138827910

Pizza(42).get_size()

42

和我们预期的一样，现在不再需要提供任何参数给_get_size，因为它已经是绑定的，它的self参数会自动地设置给Pizza实例，下面代码是最好的证明：

Python

1

2

3

m = Pizza(42).get_size

m()

42

更有甚者，你都没必要使用持有Pizza对象的引用了，因为该方法已经绑定到了这个对象，所以这个方法对它自己来说是已经足够了。

也许，如果你想知道这个绑定的方法是绑定在哪个对象上，下面这种手段就能得知：

Python

1

2

3

4

5

6

7

m = Pizza(42).get_size

m.__self__

__main__.Pizza object at 0x7f3138827910

# You could guess, look at this:

...

m == m.__self__.get_size

True

显然，该对象仍然有一个引用存在，只要你愿意你还是可以把它找回来。

在Python3中，依附在类上的函数不再当作是未绑定的方法，而是把它当作一个简单地函数，如果有必要它会绑定到一个对象身上去，原则依然和Python2保持一致，但是模块更简洁：

Python

1

2

3

4

5

6

7

8

class Pizza(object):

...     def __init__(self, size):

...         self.size = size

...     def get_size(self):

...         return self.size

...

Pizza.get_size

function Pizza.get_size at 0x7f307f984dd0

静态方法

静态方法是一类特殊的方法，有时你可能需要写一个属于这个类的方法，但是这些代码完全不会使用到实例对象本身，例如：

Python

1

2

3

4

5

6

7

class Pizza(object):

@staticmethod

def mix_ingredients(x, y):

return x + y

def cook(self):

return self.mix_ingredients(self.cheese, self.vegetables)

这个例子中，如果把_mix_ingredients作为非静态方法同样可以运行，但是它要提供self参数，而这个参数在方法中根本不会被使用到。这里的@staticmethod装饰器可以给我们带来一些好处：

Python不再需要为Pizza对象实例初始化一个绑定方法，绑定方法同样是对象，但是创建他们需要成本，而静态方法就可以避免这些。

Python

1

2

3

4

5

6

Pizza().cook is Pizza().cook

False

Pizza().mix_ingredients is Pizza.mix_ingredients

True

Pizza().mix_ingredients is Pizza().mix_ingredients

True

可读性更好的代码，看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。

可以在子类中被覆盖，如果是把mix_ingredients作为模块的顶层函数，那么继承自Pizza的子类就没法改变pizza的mix_ingredients了如果不覆盖cook的话。

类方法

话虽如此，什么是类方法呢？类方法不是绑定到对象上，而是绑定在类上的方法。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

class Pizza(object):

...     radius = 42

...     @classmethod

...     def get_radius(cls):

...         return cls.radius

...

Pizza.get_radius

bound method type.get_radius of class '__main__.Pizza'

Pizza().get_radius

bound method type.get_radius of class '__main__.Pizza'

Pizza.get_radius is Pizza().get_radius

True

Pizza.get_radius()

42

无论你用哪种方式访问这个方法，它总是绑定到了这个类身上，它的第一个参数是这个类本身（记住：类也是对象）。

什么时候使用这种方法呢？类方法通常在以下两种场景是非常有用的：

工厂方法：它用于创建类的实例，例如一些预处理。如果使用@staticmethod代替，那我们不得不硬编码Pizza类名在函数中，这使得任何继承Pizza的类都不能使用我们这个工厂方法给它自己用。

Python

1

2

3

4

5

6

7

class Pizza(object):

def __init__(self, ingredients):

self.ingredients = ingredients

@classmethod

def from_fridge(cls, fridge):

return cls(fridge.get_cheese() + fridge.get_vegetables())

调用静态类：如果你把一个静态方法拆分成多个静态方法，除非你使用类方法，否则你还是得硬编码类名。使用这种方式声明方法，Pizza类名明永远都不会在被直接引用，继承和方法覆盖都可以完美的工作。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

class Pizza(object):

def __init__(self, radius, height):

self.radius = radius

self.height = height

@staticmethod

def compute_area(radius):

return math.pi * (radius ** 2)

@classmethod

def compute_volume(cls, height, radius):

return height * cls.compute_area(radius)

def get_volume(self):

return self.compute_volume(self.height, self.radius)

抽象方法

抽象方法是定义在基类中的一种方法，它没有提供任何实现，类似于Java中接口(Interface)里面的方法。

在Python中实现抽象方法最简单地方式是：

Python

1

2

3

class Pizza(object):

def get_radius(self):

raise NotImplementedError

任何继承自_Pizza的类必须覆盖实现方法get_radius，否则会抛出异常。

这种抽象方法的实现有它的弊端，如果你写一个类继承Pizza，但是忘记实现get_radius，异常只有在你真正使用的时候才会抛出来。

Python

1

2

3

4

5

6

7

Pizza()

__main__.Pizza object at 0x7fb747353d90

Pizza().get_radius()

Traceback (most recent call last):

File "stdin", line 1, in module

File "stdin", line 3, in get_radius

NotImplementedError

还有一种方式可以让错误更早的触发，使用Python提供的abc模块，对象被初始化之后就可以抛出异常：

Python

1

2

3

4

5

6

7

8

import abc

class BasePizza(object):

__metaclass__  = abc.ABCMeta

@abc.abstractmethod

def get_radius(self):

"""Method that should do something."""

使用abc后，当你尝试初始化BasePizza或者任何子类的时候立马就会得到一个TypeError，而无需等到真正调用get_radius的时候才发现异常。

Python

1

2

3

4

BasePizza()

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合静态方法、类方法、抽象方法

当你开始构建类和继承结构时，混合使用这些装饰器的时候到了，所以这里列出了一些技巧。

记住，声明一个抽象的方法，不会固定方法的原型，这就意味着虽然你必须实现它，但是我可以用任何参数列表来实现：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

import abc

class BasePizza(object):

__metaclass__  = abc.ABCMeta

@abc.abstractmethod

def get_ingredients(self):

"""Returns the ingredient list."""

class Calzone(BasePizza):

def get_ingredients(self, with_egg=False):

egg = Egg() if with_egg else None

return self.ingredients + egg

这样是允许的，因为Calzone满足BasePizza对象所定义的接口需求。同样我们也可以用一个类方法或静态方法来实现：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

import abc

class BasePizza(object):

__metaclass__  = abc.ABCMeta

@abc.abstractmethod

def get_ingredients(self):

"""Returns the ingredient list."""

class DietPizza(BasePizza):

@staticmethod

def get_ingredients():

return None

这同样是正确的,因为它遵循抽象类BasePizza设定的契约。事实上get_ingredients方法并不需要知道返回结果是什么，结果是实现细节，不是契约条件。

因此，你不能强制抽象方法的实现是一个常规方法、或者是类方法还是静态方法，也没什么可争论的。从Python3开始（在Python2中不能如你期待的运行，见issue5867），在abstractmethod方法上面使用@staticmethod和@classmethod装饰器成为可能。

Python

1

2

3

4

5

6

7

8

9

10

11

12

import abc

class BasePizza(object):

__metaclass__  = abc.ABCMeta

ingredient = ['cheese']

@classmethod

@abc.abstractmethod

def get_ingredients(cls):

"""Returns the ingredient list."""

return cls.ingredients

别误会了，如果你认为它会强制子类作为一个类方法来实现get_ingredients那你就错了，它仅仅表示你实现的get_ingredients在BasePizza中是一个类方法。

可以在抽象方法中做代码的实现？没错，Python与Java接口中的方法相反，你可以在抽象方法编写实现代码通过super()来调用它。（译注：在Java8中，接口也提供的默认方法，允许在接口中写方法的实现）

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

import abc

class BasePizza(object):

__metaclass__  = abc.ABCMeta

default_ingredients = ['cheese']

@classmethod

@abc.abstractmethod

def get_ingredients(cls):

"""Returns the ingredient list."""

return cls.default_ingredients

class DietPizza(BasePizza):

def get_ingredients(self):

return ['egg'] + super(DietPizza, self).get_ingredients()

这个例子中，你构建的每个pizza都通过继承BasePizza的方式，你不得不覆盖get_ingredients方法，但是能够使用默认机制通过super()来获取ingredient列表。

打赏支持我翻译更多好文章，谢谢！

分享文章：python函数抽象原则 抽象函数入门
标题URL：http://ybzwz.com/article/dodeigo.html