博客分类：
##1.如何还原函数的参数调用
##什么也不说了,copy and run
##有什么用,自己想象吧
def show_para(func):
func_id="%s.%s"%(func.__module__,func.__name__)
varnames=func.func_code.co_varnames
if func.func_defaults:
varnames_len=len(varnames)
defaults=[repr(i) for i in func.func_defaults]
def get_id(args,kwds):
paras=[repr(i) for i in args]
len_args=len(args)
pos=len_args-varnames_len
for i in varnames[len_args:]:
paras.append(
repr(kwds.get(i,defaults[pos]))
paras.extend(defaults[pos:])
return "%s(%s)"%(func_id,",".join(paras))[-250:]
def get_id(args,kwds):
paras=[repr(i) for i in args]
for i in varnames[len(args):]:
paras.append(
repr(kwds[i])
return "%s(%s)"%(func_id,",".join(paras))[-250:]
def _func(*args,**kwds):
print get_id(args,kwds)
print len(get_id(args,kwds))
return _func
@show_para
def xxx(a,b,c,d="张",e="沈",f="鹏",g=2):
@show_para
def ooo(a,b,c):
xxx(1,2,3,f=121)
ooo(1,2,3)
########################################################################
##2.元类与缓存
#coding:utf-8
##同样,copy and run
##不做解释,自己想象
from types import ClassType
class mc(object):
__cache={}
@staticmethod
def get(id):
r=mc.__cache.get(id,None)
print "mc.get\t%s = %s"%(id,r)
@staticmethod
def set(id,value):
print "mc.set\t%s = %s"%(id,value)
mc.__cache[id]=value
@staticmethod
def delete(id):
print "mc.delete \t%s"%(id)
mc.__cache.pop(id)
class MetaMc(type):
使用该元类的类
如果自定义__init__必须第一个参数必须是id
否则,生成的__init__第一个参数默认是id
def __new__(cls,classname,bases,classdict):
class_id="%s.%s:"%(classdict['__module__'],classname)
def init_maker(init):
for i in bases:
if isinstance(i,MetaMc):
def __init__(self,id,*args,**kwds):
return init(self,id,*args,**kwds)
return __init__
def __init__(self,id,*args,**kwds):
self.__id=int(id)
self.__mc_id="%s%s"%(class_id,id)
self.__profile=mc.get(self.__mc_id) or {}
init(self,id,*args,**kwds)
if isinstance(bases[0],MetaMc):
return None
def __init__(self,id,*args,**kwds):
self.__id=int(id)
self.__mc_id="%s%s"%(class_id,id)
self.__profile=mc.get(self.__mc_id) or {}
return bases[0].__init__(self,*args,**kwds)
def __init__(self,id,*args,**kwds):
self.__id=int(id)
self.__mc_id="%s%s"%(class_id,id)
self.__profile=mc.get(self.__mc_id) or {}
return __init__
__init__=init_maker(classdict.get("__init__",None))
if __init__:
classdict["__init__"]=__init__
def id(self):
return self.__id
classdict["id"]=id
if "__repr__" not in classdict:
def __repr__(self):
return self.__mc_id
classdict["__repr__"]=__repr__
if "__str__" not in classdict:
def __str__(self):
return self.__mc_id
classdict["__str__"]=__str__
def mc_clean(self):
self.__profile={}
mc.delete(self.__mc_id)
classdict["mc_clean"]=mc_clean
def get_maker(k,v):
def get(self):
profile=self.__profile
if k in profile:
result=profile[k]
result=v.get.im_func(self)
profile[k]=result
mc.set(self.__mc_id,profile)
self.__profile=profile
return result
return get
def set_maker(k,v):
def set(self,value):
result=v.set.im_func(self,value)
self.__profile[k]=value
mc.set(self.__mc_id,self.__profile)
return result
return set
for k,v in classdict.iteritems():
if isinstance(v,ClassType):
has_get=hasattr(v,"get")
has_set=hasattr(v,"set")
if has_set and has_get:
classdict[k]=property(get_maker(k,v),set_maker(k,v))
elif has_get:
classdict[k]=property(get_maker(k,v))
elif has_set:
classdict[k]=property(fset=set_maker(k,v))
return type.__new__(cls, classname, bases, classdict)
__metaclass__=MetaMc
class name:
def get(self):
return db.name
def set(self,value):
db.name=value
class amount:
def get(self):
return "amount %s"%db.amount
def set(self,value):
class B(A):
print b.name
print b.name
print b.name
print b.name
print b.name
b.mc_clean()
print b.name
print b.id
print type(b.id)
浏览: 1095448 次
来自: 江苏
的确，不要自己的支持就说完美支持，我的就不行，别说我的不是fi ...
事件长微博，欢迎转发：http://weibo.com/332 ...
没有报错，但排版效果一点都没有 咋回事。请指教
耍人呀，效果在哪儿呀
这个能监到控子目录吗？，我测试了一下，发现子目录里的文件监控不 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'# -*- coding: UTF-8 -*-
class ClassGauss(object):
def __init__(self, a, b):
super(ClassGauss, self).__init__()
self.a = a
self.b = b
self.n = len(self.b)
def max(self, max_i, max_v, i, j):# get max
a = self.a
abs_of_a = abs(a[i][j])
if max_v & abs_of_a:
max_v = abs_of_a
return max_i, max_v
def swap(self, ai, j):# change line
a = self.a
b = self.b
n = self.n
for i in range(0, n):
temp = a[ai][i]
a[ai][i] = a[j][i]
a[j][i] = temp
tempb = b[ai]
b[ai] = b[j]
b[j] = tempb
def gauss(self):
n = self.n
max_i = 0 # line num of max value
max_v = m = self.a[0][0]
for j in range(0, n-1):
for i in range(j, n):
max_i, max_v = self.max(max_i, max_v, i, j)
if max_v == 0:
raise ValueError('no unique solution')
print('max_v = %f' % max_v)
print('max_i = %f , j = %f' % (max_i, j))
if max_i != j:
# jiaohuan ai hang he ajhang
self.swap(max_i, j)
print('SWAP*******')
print(self.a)
print(self.b)
for p in range(j+1, n):
a[p][j] / a[j][j]
# print('l = %f' % (l))
b[p] -= l * b[j]
for q in range(j, n):
a[p][q] -= l * a[j][q]
print('CAL_a******')
print(self.a)
print(self.b)
print("************************")
print(self.a)
print(self.b)
self.calculate()
def calculate(self):
n = self.n - 1
xn = b[n] / a[n][n]
print('xn = %f'% xn)
if __name__ == '__main__':
# example1
a = [[0.012, 0.0],
[1.000, 0.],
[, 4.200]]
b = [0., 983.3]
debug = False
# example2
# a = [[2.00, -4.00, 2.00],[1.00, 2.00, 3.00],[-3.00, -2.00, 5.00]]
# b = [2.00, 3.00, 1.00]
g = ClassGauss(a,b)
python 实现高斯消元法
步骤1 检查A，b是否行数相同步骤2 构造增广矩阵Ab步骤3 逐列转换Ab为化简行阶梯形矩阵 中文维基链接对于Ab的每一列（最后一列除外）
当前列为列c
寻找列c中 对角线以及对角线以...
Lines_gauss——检测图像中的线条及其宽度，在视觉表面检测方面应用广泛。
lines_gauss(Image : Lines : Sigma, Low, High, LightDark, ExtractWidth, LineModel, CompleteJunctions ...
高斯消元法的python实现
高斯消元法是解线性方程组的一种常见的方法，下面是高斯消元法的实现过程，下面的算法仅能解决各主元素不为0的情况。
下面是算法的实现思路：
1.算法总共分为两大步骤，第一个步骤是将增广矩阵消元形成上三...
高斯消元法（三）：用Python简单实现顺序消元法
# coding:utf-8
import numpy as np
import sys
# 设置矩阵
def set_matrix():
# 设置系数矩阵A
matrix_a =...
Python计算——高斯消元法解线性方程组
#!/usr/bin/env python# coding=gb2312# 以上的信息随自己的需要改动吧def print_matrix( info, m ): # 输出矩阵 i = 0; j = 0...
列主元高斯消去法（C语言）
高斯消元法是将方程组中的一方程的未知数用含有另一未知数的代数式表示，并将其代人到另一方程中，这就消去了一未知数，得到一解；或将方程组中的一方程倍乘某个常数加到另外一方程中去，也可达到消去一未知数的目的...
高斯消去法与列主元消去法
两种消去法在matlab中的实现
两种消去法的实现主要是，通过函数的实现，传入参数来实现的。如有其他需要，请另行修改代码
高斯消去法函数实现
传入参数为矩阵A，向量b，以及维度...
列主元消去法求解线性方程组（C++实现）
接着上次的继续，上次使用了高斯消元法http://blog.csdn.net/qq_/article/details/，但是，在消元过程中，无法使主元素a(ii)≠0，...
计算方法之用高斯列主元消去法求线性方程组
/*************************************
* 用高斯列主元消去法求线性方程组
* 2*x1 + 2*x2 + 3*x3 = 3
*{4*x1 + 7*x2 +...
没有更多推荐了，python之元编程（元类实例） - 小生有悔 - 博客园
随笔 - 20, 文章 - 2, 评论 - 0, 引用 - 0
本实例是元类实例，功能是记录该的子类的类名，并以树状结构展示子类的类名。
RegisterClasses继承自type，提供的功能是在__init__接口，为类创建了childrens的集合，并类名保存到对应的父类元组的childrens的集合中。
同时对__str__打印方法和__iter__迭代方法进行了定义，其中：
__iter__方法返回类名的childrens集合，并对其中的元素进行输入。
而Sharp继承自RegisterClasses， 当&for s in Sharp: print s，则会调用继承来的__iter__方法。
class Round(Shape): passclass Square(Shape): passclass Triangular(Shape): passclass Boxy(Shape): pass上述操作中，Round,Square,Triangular,Boxy均初始化一个childrens的集合，同时，均将自身的类名添加到Shape元类的childrens的集合里。class Circle(Round): passclass Ellipse(Round): pass
上述操作中，Circle，Ellipse均初始化一个childrens的集合，同时，均将自身的类名添加到Round，Shape的childrens的集合里，
原因是：Round的父类是Shape，故Circle，Ellipse均有两个父类。
代码如下：
#!/usr/bin/env python# encoding: utf-8"""@author: @contract:@file: homework5_1.py@time:
14:22"""class RegisterClasses(type):
def __init__(cls, name, bases, atts):
super(RegisterClasses, cls).__init__(name, bases, atts)
#创建一个集合，这样继承元类，都会有一个childrens的集合
cls.childrens = set()
#将把当前的子类保存到父类中去
for base in bases:
if hasattr(base, 'childrens'):
base.childrens.add(cls)
#classmethod, called on class object
def __iter__(cls):
return iter(cls.childrens)
def __str__(cls):
if len(cls.childrens) & 0:
return cls.__name__ + ": " + ", ".join([sc.__name__ for sc in cls])
return cls.__name__class Shape(object):
__metaclass__ = RegisterClassesprint "---------------------"class Round(Shape): passclass Square(Shape): passclass Triangular(Shape): passclass Boxy(Shape): passprint Shapeprint "---------------------"class Circle(Round): passclass Ellipse(Round): passprint Shapeprint "---------------------"for s in Shape: #Iterator over subclasses (def __str__(cls):)
print sprint "---------------------"for cls in Shape.childrens:
if len(cls.childrens) & 0:
print cls.__name__ + ": " + ", ".join([sc.__name__ for sc in cls])
print cls.__name__输出如下：
---------------------Shape: Triangular, Boxy, Square, Round---------------------Shape: Triangular, Boxy, Square, Round---------------------TriangularBoxySquareRound: Ellipse, Circle---------------------TriangularBoxySquareRound: Ellipse, Circle&nbsp>&nbsp
&nbsp>&nbsp
&nbsp>&nbsp
Python中元类的执行优先次序
摘要：Python元类的执行顺序测试在stackoverflow上关于元类的高票答案中提到了Python中的元类的优先次序为是否在Foo中有__metaclass__属性?如果有,在内存中通过使用__metaclass__中指定的和Foo这个名字创建类对象。如果找不到__metaclass__,Python将会使用Bar(Foo的第一个父类)的metaclass(可能是默认的type)来创建类对象。如果Python找不到__metaclass__,Python将会在模块层次寻找__
Python元类的执行顺序测试
在stackoverflow上关于元类的高票答案中提到了Python中的元类的优先次序为
是否在Foo中有__metaclass__属性?如果有,在内存中通过使用__metaclass__中指定的和Foo这个名字创建类对象。
如果找不到__metaclass__,Python将会使用Bar(Foo的第一个父类)的metaclass(可能是默认的type)来创建类对象。
如果Python找不到__metaclass__,Python将会在模块层次寻找__metaclass__,并且尝试做相同的事情(仅仅对没有继承任何类的类,基本上都是old-style classes基本上可以认为是没有继承object的类,super就不适用于old-style classes)
现在测试如下:
class MetaClassTest1class(type):
def __new__(cls, clsname, bases, dct):
dct['test'] = 1
return super(MetaClassTest1class, cls).__new__(cls, clsname, bases, dct)
class MetaClassTest2class(type):
def __new__(cls, clsname, bases, dct):
dct['test'] = 2
return super(MetaClassTest2class, cls).__new__(cls, clsname, bases, dct)
__metaclass__ = MetaClassTest1class
class Foo():
__metaclass__ = MetaClassTest2class
print f.test
输出为2,所以会优先调用自己的__metaclass__
class MetaClassTest1class(type):
def __new__(cls, clsname, bases, dct):
dct['test'] = 1
return super(MetaClassTest1class, cls).__new__(cls, clsname, bases, dct)
class MetaClassTest2class(type):
def __new__(cls, clsname, bases, dct):
dct['test'] = 2
return super(MetaClassTest2class, cls).__new__(cls, clsname, bases, dct)
class MetaClassTest3class(MetaClassTest2class):
def __new__(cls, clsname, bases, dct):
dct['test'] = 3
return super(MetaClassTest3class, cls).__new__(cls, clsname, bases, dct)
__metaclass__ = MetaClassTest1class
class Foo():
__metaclass__ = MetaClassTest2class
class FooChild(Foo):
print f.test
输出为2,所以在自己没有__metalcass__的情况下,看起来会使用父类的__metaclass__
class MetaClassTest1class(type):
def __new__(cls, clsname, bases, dct):
dct['test'] = 1
return super(MetaClassTest1class, cls).__new__(cls, clsname, bases, dct)
__metaclass__ = MetaClassTest1class
class Foo():
class FooChild(Foo):
print f.test
输出为1,所以可以看到,在自身没有元类,父类没有元类的时候会使用模块中的元类。
以上是的内容，更多
的内容，请您使用右上方搜索功能获取相关信息。
若你要投稿、删除文章请联系邮箱：zixun-group@service.aliyun.com,工作人员会在五个工作日内给你回复。
新用户大礼包！
现在注册，免费体验40+云产品，及域名优惠！
云服务器 ECS
可弹性伸缩、安全稳定、简单易用
&40.8元/月起
预测未发生的攻击
&24元/月起
你可能还喜欢
你可能感兴趣
阿里云教程中心为您免费提供
Python中元类的执行优先次序相关信息，包括
的信息，所有Python中元类的执行优先次序相关内容均不代表阿里云的意见！投稿删除文章请联系邮箱：zixun-group@service.aliyun.com，工作人员会在五个工作日内答复
售前咨询热线
支持与服务
资源和社区
关注阿里云
International}