python静态

A. python怎么实现静态变量

单纯的静态变量，不就是常量么。

python中，没有static，定义常量的话。

PI=3.14

使用大写字母，表示常量，以示与变量的区别。

B. python页面静态化可以用什么方法有哪些

主要特点就是需要绑定到一个对象上，python解析器会自动把实例自身传递给方法，如14行所示，而直接使用InstanceMethod.f1()调用方法是不行的。

class InstanceMethod(object):
def __init__(self, a):
self.a = a
def f1(self):
print 'This is {0}.'.format(self)
def f2(self, a):
print 'Value:{0}'.format(a)
if __name__ == '__main__':
# im = InstanceMethod()
im = InstanceMethod('233')
im.f1()
# im.f2()
im.f2(233)

C. python的静态方法有什么用

ython的静态方法和类成员方法都可以被类或实例访问，两者概念不容易理清，但还是有区别的：
1）静态方法无需传入self参数，类成员方法需传入代表本类的cls参数；
2）从第1条，静态方法是无法访问实例变量的，而类成员方法也同样无法访问实例变量，但可以访问类变量；
3）静态方法有点像函数工具库的作用，而类成员方法则更接近类似Java面向对象概念中的静态方法。

D. python静态方法和类方法的区别

面相对象程序设计中，类方法和静态方法是经常用到的两个术语。

逻辑上讲：类方法是只能由类名调用；静态方法可以由类名或对象名进行调用。

在C++中，静态方法与类方法逻辑上是等价的，只有一个概念，不会混淆。

而在Python中，方法分为三类实例方法、类方法、静态方法。代码如下：

class Test(object):

def InstanceFun(self):
print("InstanceFun");
print(self);

@classmethod
def ClassFun(cls):
print("ClassFun");
print(cls);

@staticmethod
def StaticFun():
print("StaticFun");

t = Test();
t.InstanceFun();＃ 输出InstanceFun，打印对象内存地址“<__main__.Test object at 0x0293DCF0>”
Test.ClassFun(); # 输出ClassFun，打印类位置 <class '__main__.Test'>
Test.StaticFun(); # 输出StaticFun
t.StaticFun(); # 输出StaticFun
t.ClassFun(); # 输出ClassFun，打印类位置 <class '__main__.Test'>
Test.InstanceFun(); # 错误，TypeError: unbound method instanceFun() must be called with Test instance as first argument

Test.InstanceFun(t); # 输出InstanceFun，打印对象内存地址“<__main__.Test object at 0x0293DCF0>”
t.ClassFun(Test); # 错误 classFun() takes exactly 1 argument (2 given)

可以看到，在PYTHON中，两种方法的主要区别在于参数。实例方法隐含的参数为类实例self，而类方法隐含的参数为类本身cls。
静态方法无隐含参数，主要为了类实例也可以直接调用静态方法。

所以逻辑上类方法应当只被类调用，实例方法实例调用，静态方法两者都能调用。主要区别在于参数传递上的区别，实例方法悄悄传递的是self引用作为参数，而类方法悄悄传递的是cls引用作为参数。

Python实现了一定的灵活性使得类方法和静态方法，都能够被实例和类二者调用

E. 如何在Python中定义静态变量

Python使用函数默认值实现函数静态变量的方法，具体方法如下：
一、Python函数默认值

Python函数默认值的使用可以在函数调用时写代码提供方便，很多时候我们只要使用默认值就可以了。 所以函数默认值在python中用到的很多，尤其是在类中间，类的初始化函数中一帮都会用到默认值。 使用类时能够方便的创建类，而不需要传递一堆参数。

只要在函数参数名后面加上 ”=defalut_value”，函数默认值就定义好了。有一个地方需要注意的是，有默认值的参数必须在函数参数列表的最后，不允许将没有默认值的参数放在有默认值的参数后，因为如果你那样定义的话，解释器将不知道如何去传递参数。

先来看一段示例代码：

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_input(prompt)
if ok in ('y', 'ye', 'yes'): return True
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
print complaint

你调用上面的函数时，可以修改重试次数和输出的提示语言，如果你比较懒得话，那么什么都不用改。

二、python使用函数默认值来实现函数静态变量的功能

Python中是不支持静态变量的，但是我们可以通过函数的默认值来实现静态变量的功能。
当函数的默认值是内容是可变的类时，类的内容可变，而类的名字没变。（相当于开辟的内存区域没有变，而其中内容可以变化）。
这是因为python中函数的默认值只会被执行一次，(和静态变量一样，静态变量初始化也是被执行一次。）这就是他们的共同点。

再来看下面的程序片段：

def f(a, L=[]):
L.append(a)
return L

print f(1)
print f(2)
print f(3)
print f(4,['x'])
print f(5)

其输出结果是：

[1]
[1, 2]
[1, 2, 3]
['x', 4]
[1, 2, 3, 5]

前面的好理解，为什么最后 “print f(5)”的输出是 “[1, 2, 3, 5]”呢？

这是因为 “print f(4,['x'])”时，默认变量并没有被改变，因为默认变量的初始化只是被执行了一次(第一次使用默认值调用)，初始化执行开辟的内存区（我们可以称之为默认变量）没有被改变，所以最后的输出结果是“[1, 2, 3, 5]”。

F. lt;译文>Python中静态方法和类方法的区别是什么

问题：What
is
the
difference
between
a
static
method
and
class
method
in
Python?
Python中静态方法和类方法的区别是什么？
问题原文：
Python
has
two
decorators
@staticmethod
and
@classmethod.
Could
someone
one
explain
the
difference
between
the
two
or
point
me
to
a
source
where
it
is
documented?
When
should
the
staticmethod
decorator
be
used
over
the
classmethod
decorator?
问题译文：
Python有两种装饰器静态方法装饰器@staticmethod
和类方法装饰器@classmethod。谁能解释一下两者的区别或者给我指点点文档资料？什么时候该用静态方法装饰器或者类方法装饰器？
Answers：
1.Maybe
a
bit
of
example
code
will
help:
Notice
the
difference
in
the
call
signatures
of
foo,
class_foo
and
static_foo:
可能一点例子代码会有帮助：注意调用函数foo、class_foo、static_foo的写法上的区别
class
A
(
object
):
def
foo
(
self
,
x
):
print
"executing
foo(%s,%s)"
%(
self
,
x
)
@classmethod
def
class_foo
(
cls
,
x
):
print
"executing
class_foo(%s,%s)"
%(
cls
,
x
)
@staticmethod
def
static_foo
(
x
):
print
"executing
static_foo(%s)"
%
x

G. python 类方法和静态方法的区别

类方法的第一个parameter是类自己，然后才是参数。而静态方法是和类无关的，也不会自动导入类作为参数。可以说静态方法只是一个和自己所在的类无关的一个方法。可以随意你怎么用这个方法。抽象点说静态方法就是你在其他语言里面用的普通方法，类方法是Java里的类方法一样的。

H. 求助Python高手，Python里有静态方法和私有方法，这两者有什么区别呢

静态方法不能访问实例的属性，私有访问只能在类的内部访问，不能被实例访问，详细看代码：

classPerson:
age=0
wegiht=0
__sex=''
def__init__(self):
pass
@staticmethod
defget_stactic_age():
Person.age+=1#这里不能用self.age访问
def__add(self):
print("这是一个私有方法，只能在类中使用")
defget_weight(self):
print("这是一个公有方法，可以被类的实例使用")
tom=Person()
tom.get_weight()#这个可以正常访问
tom.__add()#这个不能正常访问,报AttributeError:'Person'objecthasnoattribute'__add'异常

I. python 里面有静态函数吗

python的类里用@staticmethod的是静态方法，@classmethod的是类方法，如下

classPerson(object):

person_list=[]

def__init__(self,name,age):
self.name=name
self.age=age
self.person_list.append(self)

@classmethod
defone_year_later(cls):
forpincls.person_list:
p.age+=1

@staticmethod
defborn_one_boby(name):
returnPerson(name,0)

def__repr__(self):
return'<Personname:%s,age:%s>'%(self.name,self.age)

if__name__=='__main__':
petter=Person('Petter',23)
merry=Person('Merry',21)
print(petter)#<Personname:Petter,age:23>
print(merry)#<Personname:Merry,age:21>
Person.one_year_later()
print(petter)#<Personname:Petter,age:24>
print(merry)#<Personname:Merry,age:22>
baby=merry.born_one_boby('Tom')
print(Person.person_list)#[<Personname:Petter,age:24>,<Personname:Merry,age:22>,<Personname:Tom,age:0>]