python动态函数函数

A. 求python代码编动态规划贝尔曼函数

classNode(object):

def__init__(self,name):
self._name=name
self._value=None
self._from=None
self._next=[]

defsetValue(self,value):
self._value=value

defsetNext(self,node):
self._next.append(node)

defsetFrom(self,node):
self._from=node

defgetValue(self):
returnself._value

defgetNext(self):
returnself._next

defgetName(self):
returnself._name

defgetFrom(self):
returnself._from

classBFtree():

def__init__(self,dList):
self._dList=dList

defbfValue(self,start):
cur=start
ifcur.getNext()isnotNone:
fornodeincur.getNext():
path=[cur.getName(),node.getName()]
path.sort()
path=''.join(path)
value=cur.getValue()+self._dList[path]
ifnode.getValue()isNoneorvalue<node.getValue():
node.setValue(value)
node.setFrom(cur)
self.bfValue(node)

defmove(self,start,end):
print'From:',start.getName(),'to:',end.getName()
start.setValue(0)
self.bfValue(start)
trace=[end.getName()]
cur=end
whilecur.getFrom()isnotNone:
cur=cur.getFrom()
trace.append(cur.getName())
trace=reversed(trace)
print'Thepathis',''.join(trace),'andthevalueis',end.getValue()

#builidngnode
a=Node('A')
b=Node('B')
c=Node('C')
d=Node('D')
e=Node('E')
f=Node('F')
g=Node('G')
h=Node('H')

#buildtree
a.setNext(b)
a.setNext(c)
a.setNext(d)

b.setNext(a)
b.setNext(g)

c.setNext(a)
c.setNext(g)
c.setNext(e)

d.setNext(a)
d.setNext(e)

e.setNext(c)
e.setNext(b)
e.setNext(f)

f.setNext(e)

g.setNext(b)
g.setNext(c)
g.setNext(h)

h.setNext(g)

#builddistancelist
dList=dict();
dList['AB']=1
dList['AC']=2
dList['AD']=3
dList['BG']=1
dList['BE']=6
dList['CE']=2
dList['CG']=5
dList['DE']=4
dList['EF']=3
dList['GH']=4

#buildBFtree
tree=BFtree(dList)
tree.move(a,h)
tree.move(a,f)
tree.move(a,e)

代码略长....

B. python的类中怎么实现动态化函数

给你这样一个例子吧，这个例子里面有动态增加类的函数。
声明一个类，类初始化的时候读取配置文件，根据配置列表加载特定目录下的模块下的函数，函数和模块同名，将此函数动态加载为类的成员函数。
代码如下所示：
class WinBAS(Bas):
def __init__(self):
self.__baslist = {}
self.__Init_Moles()
pass
def __Init_Moles(self):
import modplugs
for m in modplugs.__moleset__:
mh = __import__('moles.' + m)# + '.' + m)
ma = getattr(mh, m)# + '.' + m)
ma = getattr(ma, m)
setattr(self.__class__, m, ma)
modplugs.py是模块配置文件如下：
__moleset__ = [
'BAS_GetUserList',
]
然后建立目录moles下面建立一个空的__init__.py文件，把目录变为一个包，在moles目录下建立真正的BAS_GetUserList实现：BAS_GetUserList文件中有个BAS_GetUserList函数如下：
def BAS_GetUserList(self, strs):
return [0, strs]

这样WinBAS类就可以动态加入了BAS_GetUserList函数。

C. python 关于函数的语法

这里的QuickSort.count叫做"函数属性function attribute"，

python等动态类型语言所具有的"函数同时是头等对象"的功能.
即代码可以往函数对象上灵活地添加某属性。

deff():
print(f.act)

f.act=123#定义和添加一个函数对象的属性-函数属性
f()#打印123

之前的快速排序用了一个count属性在记录排序算法的比较次数。属于调试显示，不是排序的核心算法..

D. python类和函数的区别

一、主体不同

1、类：是面向对象程序设计实现信息封装的基础。

2、函数：是指一段在一起的、可以做某一件事儿的程序。也叫做子程序、（OOP中）方法。

二、特点不同

1、类：是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

2、函数：分为全局函数、全局静态函数；在类中还可以定义构造函数、析构函数、拷贝构造函数、成员函数、友元函数、运算符重载函数、内联函数等。

三、规则不同

1、类：实质是一种引用数据类型，类似于byte、short、int(char)、long、float、double等基本数据类型，不同的是它是一种复杂的数据类型。

2、函数：函数必须声明后才可以被调用。调用格式为：函数名（实参）调用时函数名后的小括号中的实参必须和声明函数时的函数括号中的形参个数相同。

E. 怎样理解Python是动态语言说出其能动态的本质原因。

它是一类在执行时能够改变其结构的语言：比如新的函数、对象、甚至代码能够被引进，已有的函数能够被删除或是其它结构上的变化。它是一类在执行时能够改变其结构的语言：比如新的函数、对象、甚至代码能够被引进，已有的函数能够被删除或是其它结构上的变化。

F. 关于python中几个函数的用法

函数调用
myFun()

# 函数的参数
# 单个参数
# 场景
# 需要动态的调整函数体中某一个处理信息
# 则可以, 以参数的形式接收到相关数据
# 定义
# def 函数名(参数名称):
# 函数体
# 函数体中, 可以直接以变量的方式使用该参数
# 函数的调用
# 函数名(参数值)
# 形参和实参的概念
# 上述函数定义中, "参数名称"即为形参;
# 在调用函数的时候, 传递的真实数据, 即为实参
# 多个参数
# 场景
# 需要动态的调整函数体中多个处理信息时
# 则可以以 逗号 做分割, 接收多个参数
# 定义
# def 函数名(参数名称1, 参数名称2):
# 函数体
# 函数体中, 可以直接以变量的方式使用所有参数
# 调用
# 方式1
# 函数名(参数1, 参数2, 参数3...)
# 形参和实参一一对应
# 方式2
# 函数名(参数名称1=参数1, 参数名称n = 参数n...)
# 可以指明形参名称
# 称为"关键字参数"
# 不需要严格按照顺序

# 不定长参数
# 场景
# 如果函数体中, 需要处理的数据, 不确定长度
# 则可以以不定长参数的方式接收数据
# 方式1
# 定义
# def 函数名(*args):
# 元组
# 函数体
# 函数体中, 可以直接以元组变量的方式使用该参数
# 使用
# 函数名(参数1, 参数2, 参数3...)

G. python 类调用函数,没有则动态生成这个函数

在某些情况可能要根据不同的参数来动态生成不同的实例方法、静态方法、类方法
动态系统是指状态随时间而变化的系统。动态系统具有这样的特点：系统的状态变量随时间有明显的变化，是时间的函数;系统状况可以由其状态变量随时间变化的信息(数据)来描述。
要特别指出的是，动态系统和系统的运动是两个不同的概念。运动是系统的基本属性，一切系统，包括静态系统，都是在不断地运动之中。唯有系统在运动中状态随时间而发生明显变化的，才是动态系统。

H. Python怎么根据不同的字符串动态选择函数

#可以用函数字典，看看是否满足你的要求
deftext_func(self):
print"thisistextfunc"
defint_func(self):
print"thisisint_func"
gen_func={'text':text_func,'int':int_func}
defchoose(a='text'):
returngen_func[a]

I. python 怎么生成可变函数名

定义一个A类，然后实例化一个A对象，通过setattr函数来给当前类添加一个变量，值是test函数。调用haha函数，就相当于调用了test函数。 例2，定义一个模块，通过另一个模块函数调用函数来增加变量，值是test2函数。调用haha函数，就相当于调用了test2函数。
原理
python系统会维护一个变量的字典，可以通过locals(）或者globals()获取到该字典。由于字典是可变对象，那么，就可以动态的增加变量。由于函数也是一个对象，那么就可以将变量指向函数。这样就可以达到动态修改函数名的目的了。