正文
meta函数python meta函数
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
有没有老师了解Python用于Meta分析的工具包
Python在科学计算领域,有两个重要的扩展模块:Numpy和Scipy。其中Numpy是一个用python实现的科学计算包。包括:
一个强大的N维数组对象Array;
比较成熟的(广播)函数库;
用于整合C/C++和Fortran代码的工具包;
实用的线性代数、傅里叶变换和随机数生成函数。
SciPy是一个开源的Python算法库和数学工具包,SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。其功能与软件MATLAB、Scilab和GNU Octave类似。
Numpy和Scipy常常结合着使用,Python大多数机器学习库都依赖于这两个模块,绘图和可视化依赖于matplotlib模块,matplotlib的风格与matlab类似。Python机器学习库非常多,而且大多数开源,主要有:
1. scikit-learn
scikit-learn 是一个基于SciPy和Numpy的开源机器学习模块,包括分类、回归、聚类系列算法,主要算法有SVM、逻辑回归、朴素贝叶斯、Kmeans、DBSCAN等,目前由INRI 资助,偶尔Google也资助一点。
项目主页:
2. NLTK
NLTK(Natural Language Toolkit)是Python的自然语言处理模块,包括一系列的字符处理和语言统计模型。NLTK 常用于学术研究和教学,应用的领域有语言学、认知科学、人工智能、信息检索、机器学习等。 NLTK提供超过50个语料库和词典资源,文本处理库包括分类、分词、词干提取、解析、语义推理。可稳定运行在Windows, Mac OS X和Linux平台上.
项目主页:
3. Mlpy
Mlpy是基于NumPy/SciPy的Python机器学习模块,它是Cython的扩展应用。包含的机器学习算法有:
l 回归
least squares, ridge regression, least angle regression, elastic net, kernel ridge regression, support vector machines (SVM), partial least squares (PLS)
l 分类
linear discriminant analysis (LDA), Basic perceptron, Elastic Net, logistic regression, (Kernel) Support Vector Machines (SVM), Diagonal Linear Discriminant Analysis (DLDA), Golub Classifier, Parzen-based, (kernel) Fisher Discriminant Classifier, k-nearest neighbor, Iterative RELIEF, Classification Tree, Maximum Likelihood Classifier
l 聚类
hierarchical clustering, Memory-saving Hierarchical Clustering, k-means
l 维度约减
(Kernel) Fisher discriminant analysis (FDA), Spectral Regression Discriminant Analysis (SRDA), (kernel) Principal component analysis (PCA)
项目主页:
4. Shogun
Shogun是一个开源的大规模机器学习工具箱。目前Shogun的机器学习功能分为几个部分:feature表示,feature预处理,核函数表示,核函数标准化,距离表示,分类器表示,聚类方法,分布,性能评价方法,回归方法,结构化输出学习器。
SHOGUN 的核心由C++实现,提供 Matlab、 R、 Octave、 Python接口。主要应用在linux平台上。
项目主页:
5. MDP
The Modular toolkit for Data Processing (MDP) ,用于数据处理的模块化工具包,一个Python数据处理框架。
从用户的观点,MDP是能够被整合到数据处理序列和更复杂的前馈网络结构的一批监督学习和非监督学习算法和其他数据处理单元。计算依照速度和内存需求而高效的执行。从科学开发者的观点,MDP是一个模块框架,它能够被容易地扩展。新算法的实现是容易且直观的。新实现的单元然后被自动地与程序库的其余部件进行整合。MDP在神经科学的理论研究背景下被编写,但是它已经被设计为在使用可训练数据处理算法的任何情况中都是有用的。其站在用户一边的简单性,各种不同的随时可用的算法,及应用单元的可重用性,使得它也是一个有用的教学工具。
项目主页:
python 常用的系统函数有哪些
1.常用内置函数:(不用import就可以直接使用)
help(obj) 在线帮助, obj可是任何类型
callable(obj) 查看一个obj是不是可以像函数一样调用
repr(obj) 得到obj的表示字符串,可以利用这个字符串eval重建该对象的一个拷贝
eval_r(str) 表示合法的python表达式,返回这个表达式
dir(obj) 查看obj的name space中可见的name
hasattr(obj,name) 查看一个obj的name space中是否有name
getattr(obj,name) 得到一个obj的name space中的一个name
setattr(obj,name,value) 为一个obj的name space中的一个name指向vale这个object
delattr(obj,name) 从obj的name space中删除一个name
vars(obj) 返回一个object的name space。用dictionary表示
locals() 返回一个局部name space,用dictionary表示
globals() 返回一个全局name space,用dictionary表示
type(obj) 查看一个obj的类型
isinstance(obj,cls) 查看obj是不是cls的instance
issubclass(subcls,supcls) 查看subcls是不是supcls的子类
类型转换函数
chr(i) 把一个ASCII数值,变成字符
ord(i) 把一个字符或者unicode字符,变成ASCII数值
oct(x) 把整数x变成八进制表示的字符串
hex(x) 把整数x变成十六进制表示的字符串
str(obj) 得到obj的字符串描述
list(seq) 把一个sequence转换成一个list
tuple(seq) 把一个sequence转换成一个tuple
dict(),dict(list) 转换成一个dictionary
int(x) 转换成一个integer
long(x) 转换成一个long interger
float(x) 转换成一个浮点数
complex(x) 转换成复数
max(...) 求最大值
min(...) 求最小值
用于执行程序的内置函数
complie 如果一段代码经常要使用,那么先编译,再运行会更快。
2.和操作系统相关的调用
系统相关的信息模块 import sys
sys.argv是一个list,包含所有的命令行参数.
sys.stdout sys.stdin sys.stderr 分别表示标准输入输出,错误输出的文件对象.
sys.stdin.readline() 从标准输入读一行 sys.stdout.write("a") 屏幕输出a
sys.exit(exit_code) 退出程序
sys.modules 是一个dictionary,表示系统中所有可用的module
sys.platform 得到运行的操作系统环境
sys.path 是一个list,指明所有查找module,package的路径.
操作系统相关的调用和操作 import os
os.environ 一个dictionary 包含环境变量的映射关系 os.environ["HOME"] 可以得到环境变量HOME的值
os.chdir(dir) 改变当前目录 os.chdir('d:\\outlook') 注意windows下用到转义
os.getcwd() 得到当前目录
os.getegid() 得到有效组id os.getgid() 得到组id
os.getuid() 得到用户id os.geteuid() 得到有效用户id
os.setegid os.setegid() os.seteuid() os.setuid()
os.getgruops() 得到用户组名称列表
os.getlogin() 得到用户登录名称
os.getenv 得到环境变量
os.putenv 设置环境变量
os.umask 设置umask
os.system(cmd) 利用系统调用,运行cmd命令
操作举例:
os.mkdir('/tmp/xx') os.system("echo 'hello' /tmp/xx/a.txt") os.listdir('/tmp/xx')
os.rename('/tmp/xx/a.txt','/tmp/xx/b.txt') os.remove('/tmp/xx/b.txt') os.rmdir('/tmp/xx')
用python编写一个简单的shell
#!/usr/bin/python
import os, sys
cmd = sys.stdin.readline()
while cmd:
os.system(cmd)
cmd = sys.stdin.readline()
用os.path编写平台无关的程序
os.path.abspath("1.txt") == os.path.join(os.getcwd(), "1.txt")
os.path.split(os.getcwd()) 用于分开一个目录名称中的目录部分和文件名称部分。
os.path.join(os.getcwd(), os.pardir, 'a', 'a.doc') 全成路径名称.
os.pardir 表示当前平台下上一级目录的字符 ..
os.path.getctime("/root/1.txt") 返回1.txt的ctime(创建时间)时间戳
os.path.exists(os.getcwd()) 判断文件是否存在
os.path.expanduser('~/dir') 把~扩展成用户根目录
os.path.expandvars('$PATH') 扩展环境变量PATH
os.path.isfile(os.getcwd()) 判断是否是文件名,1是0否
os.path.isdir('c:\Python26\temp') 判断是否是目录,1是0否
os.path.islink('/home/huaying/111.sql') 是否是符号连接 windows下不可用
os.path.ismout(os.getcwd()) 是否是文件系统安装点 windows下不可用
os.path.samefile(os.getcwd(), '/home/huaying') 看看两个文件名是不是指的是同一个文件
os.path.walk('/home/huaying', test_fun, "a.c")
遍历/home/huaying下所有子目录包括本目录,对于每个目录都会调用函数test_fun.
例:在某个目录中,和他所有的子目录中查找名称是a.c的文件或目录。
def test_fun(filename, dirname, names): //filename即是walk中的a.c dirname是访问的目录名称
if filename in names: //names是一个list,包含dirname目录下的所有内容
print os.path.join(dirname, filename)
os.path.walk('/home/huaying', test_fun, "a.c")
文件操作
打开文件
f = open("filename", "r") r只读 w写 rw读写 rb读二进制 wb写二进制 w+写追加
读写文件
f.write("a") f.write(str) 写一字符串 f.writeline() f.readlines() 与下read类同
f.read() 全读出来 f.read(size) 表示从文件中读取size个字符
f.readline() 读一行,到文件结尾,返回空串. f.readlines() 读取全部,返回一个list. list每个元素表示一行,包含"\n"\
f.tell() 返回当前文件读取位置
f.seek(off, where) 定位文件读写位置. off表示偏移量,正数向文件尾移动,负数表示向开头移动。
where为0表示从开始算起,1表示从当前位置算,2表示从结尾算.
f.flush() 刷新缓存
关闭文件
f.close()
regular expression 正则表达式 import re
简单的regexp
p = re.compile("abc") if p.match("abc") : print "match"
上例中首先生成一个pattern(模式),如果和某个字符串匹配,就返回一个match object
除某些特殊字符metacharacter元字符,大多数字符都和自身匹配。
这些特殊字符是 。^ $ * + ? { [ ] \ | ( )
字符集合(用[]表示)
列出字符,如[abc]表示匹配a或b或c,大多数metacharacter在[]中只表示和本身匹配。例:
a = ".^$*+?{\\|()" 大多数metachar在[]中都和本身匹配,但"^[]\"不同
p = re.compile("["+a+"]")
for i in a:
if p.match(i):
print "[%s] is match" %i
else:
print "[%s] is not match" %i
在[]中包含[]本身,表示"["或者"]"匹配.用
和
表示.
^出现在[]的开头,表示取反.[^abc]表示除了a,b,c之外的所有字符。^没有出现在开头,即于身身匹配。
-可表示范围.[a-zA-Z]匹配任何一个英文字母。[0-9]匹配任何数字。
\在[]中的妙用。
\d [0-9]
\D [^0-9]
\s [ \t\n\r\f\v]
\S [^ \t\n\r\f\v]
\w [a-zA-Z0-9_]
\W [^a-zA-Z0-9_]
\t 表示和tab匹配, 其他的都和字符串的表示法一致
\x20 表示和十六进制ascii 0x20匹配
有了\,可以在[]中表示任何字符。注:单独的一个"."如果没有出现[]中,表示出了换行\n以外的匹配任何字符,类似[^\n].
regexp的重复
{m,n}表示出现m个以上(含m个),n个以下(含n个). 如ab{1,3}c和abc,abbc,abbbc匹配,不会与ac,abbbc匹配。
m是下界,n是上界。m省略表下界是0,n省略,表上界无限大。
*表示{,} +表示{1,} ?表示{0,1}
最大匹配和最小匹配 python都是最大匹配,如果要最小匹配,在*,+,?,{m,n}后面加一个?.
match object的end可以得到匹配的最后一个字符的位置。
re.compile("a*").match('aaaa').end() 4 最大匹配
re.compile("a*?").match('aaaa').end() 0 最小匹配
使用原始字符串
字符串表示方法中用\\表示字符\.大量使用影响可读性。
解决方法:在字符串前面加一个r表示raw格式。
a = r"\a" print a 结果是\a
a = r"\"a" print a 结果是\"a
使用re模块
先用re.compile得到一个RegexObject 表示一个regexp
后用pattern的match,search的方法,得到MatchObject
再用match object得到匹配的位置,匹配的字符串等信息
RegxObject常用函数:
re.compile("a").match("abab") 如果abab的开头和re.compile("a")匹配,得到MatchObject
_sre.SRE_Match object at 0x81d43c8
print re.compile("a").match("bbab")
None 注:从str的开头开始匹配
re.compile("a").search("abab") 在abab中搜索第一个和re_obj匹配的部分
_sre.SRE_Match object at 0x81d43c8
print re.compile("a").search("bbab")
_sre.SRE_Match object at 0x8184e18 和match()不同,不必从开头匹配
re_obj.findall(str) 返回str中搜索所有和re_obj匹配的部分.
返回一个tuple,其中元素是匹配的字符串.
MatchObject的常用函数
m.start() 返回起始位置,m.end()返回结束位置(不包含该位置的字符).
m.span() 返回一个tuple表示(m.start(), m.end())
m.pos(), m.endpos(), m.re(), m.string()
m.re().search(m.string(), m.pos(), m.endpos()) 会得到m本身
m.finditer()可以返回一个iterator,用来遍历所有找到的MatchObject.
for m in re.compile("[ab]").finditer("tatbxaxb"):
print m.span()
高级regexp
| 表示联合多个regexp. A B两个regexp,A|B表示和A匹配或者跟B匹配.
^ 表示只匹配一行的开始行首,^只有在开头才有此特殊意义。
$ 表示只匹配一行的结尾
\A 表示只匹配第一行字符串的开头 ^匹配每一行的行首
\Z 表示只匹配行一行字符串的结尾 $匹配第一行的行尾
\b 只匹配词的边界 例:\binfo\b 只会匹配"info" 不会匹配information
\B 表示匹配非单词边界
示例如下:
print re.compile(r"\binfo\b").match("info ") #使用raw格式 \b表示单词边界
_sre.SRE_Match object at 0x817aa98
print re.compile("\binfo\b").match("info ") #没有使用raw \b表示退格符号
None
print re.compile("\binfo\b").match("\binfo\b ")
_sre.SRE_Match object at 0x8174948
分组(Group) 示例:re.compile("(a(b)c)d").match("abcd").groups() ('abc', 'b')
#!/usr/local/bin/python
import re
x = """
name: Charles
Address: BUPT
name: Ann
Address: BUPT
"""
#p = re.compile(r"^name:(.*)\n^Address:(.*)\n", re.M)
p = re.compile(r"^name:(?P.*)\n^Address:(?P.*)\n", re.M)
for m in p.finditer(x):
print m.span()
print "here is your friends list"
print "%s, %s"%m.groups()
Compile Flag
用re.compile得到RegxObject时,可以有一些flag用来调整RegxObject的详细特征.
DOTALL, S 让.匹配任意字符,包括换行符\n
IGNORECASE, I 忽略大小写
LOCALES, L 让\w \W \b \B和当前的locale一致
MULTILINE, M 多行模式,只影响^和$(参见上例)
VERBOSE, X verbose模式
scrapy的request的meta参数是什么意思
meta属性是字典,字典格式即{‘key’:'value'},字典是另一种可变容器模型,且可存储任意类型对象。
request中meta参数meta函数python的作用是传递信息给下一个函数,这些信息可以是任意类型的,比如值、字符串、列表、字典......方法是把要传递的信息赋值给meta字典的键,分析见如下语句(爬虫文件)meta函数python:
class example(scrapy.Spider):
name='example'
allowed_domains=['example.com']
start_urls=['']
def parse(self,response):
#从start_urls中分析出的一个网址赋值给url
url=respense.xpath('.......').extract()
#ExamleClass是在items.py中定义的,下面会写出。item本身
作者:知乎用户
链接:
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
核心解密Python函数在(类与函数之间)和(类与类之间)互相调用
首先来看一个函数间的调用
类方法:
执行结果:
metaclass能有什么用处,先来个感性的认识:
1.1 在wiki上面,metaclass是这样定义的:In object-oriented programming,
a metaclass is a class whose instances are classes.
Just as an ordinary class defines the behavior of certain objects,
a metaclass defines the behavior of certain classes and their instances.
也就是说metaclass的实例化结果是类,而class实例化的结果是instance。我是这么理解的:
metaclass是类似创建类的模板,所有的类都是通过他来create的(调用 new ),这使得你可以自由的控制
创建类的那个过程,实现你所需要的功能。
当然你也可以用函数的方式(下文会讲)
4.1 用类的形式
4.1.1 类继承于type, 例如: class Meta(type):pass
4.1.2 将需要使用metaclass来构建class的类的 metaclass 属性(不需要显示声明,直接有的了)赋值为Meta(继承于type的类)
4.2 用函数的形式
4.2.1 构建一个函数,例如叫metaclass_new, 需要3个参数:name, bases, attrs,
name: 类的名字
bases: 基类,通常是tuple类型
attrs: dict类型,就是类的属性或者函数
4.2.2 将需要使用metaclass来构建class的类的 metaclass 属性(不需要显示声明,直接有的了)赋值为函数metaclas_new
5.1 basic
metaclass的原理其实是这样的:当定义好类之后,创建类的时候其实是调用了type的 new 方法为这个类分配内存空间,创建
好了之后再调用type的 init 方法初始化(做一些赋值等)。所以metaclass的所有magic其实就在于这个 new 方法里面了。
说说这个方法: new (cls, name, bases, attrs)
cls: 将要创建的类,类似与self,但是self指向的是instance,而这里cls指向的是class
name: 类的名字,也就是我们通常用类名. name 获取的。
bases: 基类
attrs: 属性的dict。dict的内容可以是变量(类属性),也可以是函数(类方法)。
所以在创建类的过程,我们可以在这个函数里面修改name,bases,attrs的值来自由的达到我们的功能。这里常用的配合方法是
getattr和setattr(just an advice)
下面实现python中在一个类中调用另一个类的函数方法
或者下面来一个号理解的例子
执行结果:
先来介绍内部类与外部类是什么?
看源码解析:
内部类调用外部类的类属性和类方法
参考文献1
参考文献2
参考文献3
如何在Python中使用static,class,abstract方法
方法在Python中是如何工作的
方法就是一个函数meta函数python,它作为一个类属性而存在,你可以用如下方式来声明、访问一个函数meta函数python:
Python
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的一个未绑定方法。这是什么意思呢?很快我们就会知道答案meta函数python:
Python
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
Pizza.get_size(Pizza(42))
42
Pizza.get_size(Pizza(42))
42
太棒了,现在用一个实例作为它的的第一个参数来调用,整个世界都清静了,如果我说这种调用方式还不是最方便的,你也会这么认为的;没错,现在每次调用这个方法的时候我们都不得不引用这个类,如果不知道哪个类是我们的对象,长期看来这种方式是行不通的。
那么Python为我们做了什么呢,它绑定了所有来自类_Pizza的方法以及该类的任何一个实例的方法。也就意味着现在属性get_size是Pizza的一个实例对象的绑定方法,这个方法的第一个参数就是该实例本身。
Python
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
m = Pizza(42).get_size
m()
42
更有甚者,你都没必要使用持有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
function Pizza.get_size at 0x7f307f984dd0
静态方法
静态方法是一类特殊的方法,有时你可能需要写一个属于这个类的方法,但是这些代码完全不会使用到实例对象本身,例如:
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
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
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 module
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 module
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 类里面的class是什么意思啊?求
python这方面很灵活。其实java也一样允许这样子。你几乎可以在任何情况下做任何事情。
通常class Meta可以放在外面。不过,这样它就不能直接访问父类的一些属性了。
所以在python里class 如果放在另一个class 里面,通常并不是为了隐藏这个class,并不是让别人看不到它。而因为它需要父类里的一些属性。需要共享。
另外直接在类里定义的一些变量,比如queryset,也是属于类全局级的。只要引用了这个类,即使没有初始化,这些变量也已经实例化。这个有些象是java里static的全局定义结果。
我们通常用这个方法来在不同的函数变量间共享 一部分数据。同时又不需要初始化一个实例并用指针指向这一部分数据。而是通过类名直接引用。
比如下面的一个用法
class Config:
pass
Config.user_name="xxx"
Config.password="yyyy"
这样。只要你在当前模块里,通过Config就可以引用到user_name和password,而不需要global这个修饰符。
关于meta函数python和meta函数的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。