python抽象类接口_python的特性是什么

‘壹’ python下的抽象类的用途和意义

抽象方法是基类中定义的方法，但却没有任何实现。在java中，可以把方法申明成一个接口。而在python中实现一个抽象方法的简单的方法是：x0dx0aclass Sheep（object）：x0dx0adef get_size(self):x0dx0araise NotImplementedErrorx0dx0a任何从Sheep继承下来的子类必须实现get_size方法。否则就会产生一个错误。但这种实现方法有个缺点。定义的子类只有调用那个方法时才会抛错。这里有个简单方法可以在类被实例化后触发它。使用python提供的abc模块。x0dx0aimport abcx0dx0aclass Sheep(object):x0dx0a__metaclass__ = [email protected] get_size(self):x0dx0areturnx0dx0a这里实例化Sheep类或任意从其继承的子类（未实现get_size）时候都会抛出异常。x0dx0a因此，通过定义抽象类，可以定义子类的共同method（强制其实现）。

‘贰’ Python语言到底有哪些优点呢

多年来，Python在各种流行编程语言中一直排名靠前，它自身的特点让Python成为世界上功能最丰富的编程语言之一，可以适用于任何项目开发，因此Python深受开发工程师的喜爱。那到底Python自身有哪些优点使得Python深得大家的喜欢，下面和四川优就业的小编一起来看看吧。
一、简单易学
Python语言的优点第一个就是简单易学，Python最大的优点之一是具有伪代码的本质，它使我们在开发Python程序时，专注的是解决问题,而不是搞明白语言本身。Python采用C语言进行开发，但是Python不再有C语言中的指针等复杂的数据类型存在。举个例子来说，同样一个程序，使用C可能需要1000行代码，使用Java需要100行代码，而使用Python则只需要20行代码。这也就是很多新手小白选择学习Python的原因，它没有那么复杂的逻辑，代码简洁规范，关键字也相对较少，说明文档还非常简单，极易上手。
二、免费开源
简单地说，我们不用花一分钱，就可以直接下载安装使用，自由的发布软件的拷贝、阅读它的源代码，还可以对其源码进行修改，并能把它的一部分用于新的自由软件中。
三、开发速度快、效率高
Python被称为“胶水语言”，并且有丰富强大库，可以实现很多强大的功能，因此Python运行速度非常快，开发效率非常高。
四、面向对象
Python具有很强的面向对象特性，同时也简单化了面向对象的实现，可以消除保护类型、抽象类、接口等面向对象的元素。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。
除了以上的这些优点，Python还有很多像可移植性强、可扩展性、可嵌入性等优势。也正是这些优点，所以造就了功能强大的Python语言。

‘叁’ python的特性是什么

Python是一门大家都比较熟悉的一门计算机语言，也是比较简单的一门计算机语言，相对于来说更加简单一些，而且也是不少人进入行业内的首要选择。
Python是一门好用又简单易学的计算机编程语言，在近几年中，Python受到了不少IT人士的追捧，热度也是越来越高了，成为了我们入门首选的编程语言，为什么呢?因为Python具有非常广泛的应用范围，在人工智能、web开发之中具有非常好的应用，同时在金融分析、爬虫等领域也具有很大的作用。
1、Python采用C语言进行开发，但是Python不再有C语言中的指针等复杂的数据类型存在。
2、Python具有很强的面向对象特性，同时也简单化了面向对象的实现，可以消除保护类型、抽象类、接口等面向对象的元素。
3、Python代码可以使用空格或者制表符缩进的方式分割代码。
4、Python仅仅只有31个保留字，而且没有分号、begin、end等标记。
5、Python是强类型的语言，变量创建之后会对应一种数据类型，出现在统一表达式中的不同类型的变量需要做类型转换。

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

方法在Python中是如何工作的

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

Python

>>> class Pizza(object):

... def __init__(self, size):

... self.size = size

... def get_size(self):

... return self.size

...

>>> Pizza.get_size

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

Python

>>> Pizza.get_size()

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

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

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

Python

>>> Pizza.get_size(Pizza(42))

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

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

Python

>>> Pizza(42).get_size

>>> Pizza(42).get_size()

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

Python

>>> m = Pizza(42).get_size

>>> m()

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

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

Python

>>> 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

>>> class Pizza(object):

... def __init__(self, size):

... self.size = size

... def get_size(self):

... return self.size

...

>>> Pizza.get_size

静态方法

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

Python

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

>>> 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

>>> class Pizza(object):

... radius = 42

... @classmethod

... def get_radius(cls):

... return cls.radius

...

>>>

>>> Pizza.get_radius

>>> Pizza().get_radius

>>> Pizza.get_radius is Pizza().get_radius

True

>>> Pizza.get_radius()

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

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

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

Python

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

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

class Pizza(object):

def get_radius(self):

raise NotImplementedError

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

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

Python

>>> Pizza()

<__main__.Pizza object at 0x7fb747353d90>

>>> Pizza().get_radius()

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

File "<stdin>", line 3, in get_radius

NotImplementedError

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

Python

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

>>> BasePizza()

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

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

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

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

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

Python

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

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

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

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中的concurrent.futures模块

concurrent.futures 模块提供了并发执行调用的高级接口

并发可以使用 threads 执行，使用 ThreadPoolExecutor 或分离的 processes ，使用 ProcessPoolExecutor 。都实现了同一个接口，这个接口在抽象类 Executor 定义

wait 等待 fs 里面所有的 Future 实例（由不同的 Executors 实例创建的）完成。返回两个命名元祖，第一个元祖名为 done ，存放完成的 futures 对象，第二个元祖名为 not_done ，存放未完成的 futures 。
return_when 参数必须是 concurrent.futures 里面定义的常量： FIRST_COMPLETED , FIRST_EXCEPTION , ALL_COMPLETED

返回一个迭代器， yield 那些完成的 futures 对象。 fs 里面有重复的也只可能返回一次。任何 futures 在调用 as_completed() 调用之前完成首先被 yield 。

Future() 封装了可调用对象的异步执行。 Future 实例可以被 Executor.submit() 方法创建。除了测试之外不应该直接创建。 Future 对象可以和异步执行的任务进行交互

1、抽象类，提供异步调用的方法。不能被直接使用，而是通过构建子类。

2、方法

shutdown(wait=True)
给 executor 发信号，使其释放资源，当 futures 完成执行时。已经 shutdown 再调用 submit() 或 map() 会抛出 RuntimeError 。使用 with 语句，就可以避免必须调用本函数

ThreadPoolExecutor 是 Executor 的子类使用线程池来异步执行调用

如果使用不正确可能会造成死锁，所以 submit 的 task 尽量不要调用 executor 和 futures ，否则很容易出现死锁

默认的max_workers是设备的处理器数目*5

ProcessPoolExecutor 使用 multiprocessing 模块，不受 GIL 锁的约束，意味着只有可以 pickle 的对象才可以执行和返回

__main__ 必须能够被工作子进程导入。所以意味着 ProcessPoolExecutor 在交互式解释器下不能工作。

提交给 ProcessPoolExecutor 的可调用方法里面调用 Executor 或 Future 将会形成死锁。

class concurrent.futures.ProcessPoolExecutor(max_workers=None)

max_workers 默认是处理器的个数

exception concurrent.futures.CancelledError

exception concurrent.futures.TimeoutError

exception concurrent.futures.process.BrokenProcessPool

‘陆’ python基础（abc类）

ABC是Abstract Base Class的缩写。
Python本身不提供抽象类和接口机制，要想实现抽象类，可以借助abc模块。
abc类中常见的方法有：ABCMeta，abstractmethod，classmethod

这是用来生成抽象基础类的元类。由它生成的类可以被直接继承。

通过注册进行具体化抽象类

通过继承具体化抽象类

‘柒’ 大数据主要学习什么呢

大数据主要学习的东西有6个方面：
第一阶段
JavaSE基础核心
第二阶段
数据库关键技术
第三阶段
大数据基础核心
第四阶段
Spark生态体系框架&大数据高薪精选项目
第五阶段
Spark生态体系框架&企业无缝对接项目
第六阶段
Flink流式数据处理框架

导航:首页 > 编程语言 > python抽象类接口

python抽象类接口

与python抽象类接口相关的资料