Python中的对象,方法,类,实例,函数用法分析,python函数

本文实例分析了Python中的对象,方法,类,实例,函数用法。分享给大家供大家参考。具体分析如下:

Python是一个完全面向对象的语言。不仅实例是对象,类,函数,方法也都是对象。

复制代码 代码如下:

class Foo(object):
    static_attr = True
    def method(self):
        pass
foo = Foo()

这段代码实际上创造了两个对象,Foo和foo。而Foo同时又是一个类,foo是这个类的实例。
在C++里类型定义是在编译时完成的,被储存在静态内存里,不能轻易修改。在Python里类型本身是对象,和实例对象一样储存在堆中,对于解释器来说类对象和实例对象没有根本上的区别。
在Python中每一个对象都有自己的命名空间。空间内的变量被存储在对象的__dict__里。这样,Foo类有一个__dict__,
foo实例也有一个__dict__,但这是两个不同的命名空间。
所谓“定义一个类”,实际上就是先生成一个类对象,然后执行一段代码,但把执行这段代码时的本地命名空间设置成类的__dict__.
所以你可以写这样的代码:

复制代码 代码如下:

>>> class Foo(object):
…     bar = 1 + 1
…     qux = bar + 1
…     print “bar: “, bar
…     print “qux: “, qux
…     print locals()

bar:  2
qux:  3
{‘qux’: 3, ‘__module__’: ‘__main__’, ‘bar’: 2}
>>> print Foo.bar, Foo.__dict__[‘bar’]
2 2
>>> print Foo.qux, Foo.__dict__[‘qux’]
3 3

所谓“定义一个函数”,实际上也就是生成一个函数对象。而“定义一个方法”就是生成一
个函数对象,并把这个对象放在一个类的__dict__中。下面两种定义方法的形式是等价的:

复制代码 代码如下:

>>> class Foo(object):
…     def bar(self):
…         return 2

>>> def qux(self):
…     return 3

>>> Foo.qux = qux
>>> print Foo.bar, Foo.__dict__[‘bar’]

>>> print Foo.qux, Foo.__dict__[‘qux’]

>>> foo = Foo()
>>> foo.bar()
2
>>> foo.qux()
3

而类继承就是简单地定义两个类对象,各自有不同的__dict__:

复制代码 代码如下:

>>> class Cheese(object):
…     smell = ‘good’
…     taste = ‘good’

>>> class Stilton(Cheese):
…     smell = ‘bad’

>>> print Cheese.smell
good
>>> print Cheese.taste
good
>>> print Stilton.smell
bad
>>> print Stilton.taste
good
>>> print ‘taste’ in Cheese.__dict__
True
>>> print ‘taste’ in Stilton.__dict__
False

复杂的地方在`.`这个运算符上。对于类来说,Stilton.taste的意思是“在Stilton.__dict__中找’taste’.
如果没找到,到父类Cheese的__dict__里去找,然后到父类的父类,等等。如果一直到object仍没找到,那么扔一个AttributeError.”
实例同样有自己的__dict__:

复制代码 代码如下:

>>> class Cheese(object):
…     smell = ‘good’
…     taste = ‘good’
…     def __init__(self, weight):
…         self.weight = weight
…     def get_weight(self):
…         return self.weight

>>> class Stilton(Cheese):
…     smell = ‘bad’

>>> stilton = Stilton(‘100g’)
>>> print ‘weight’ in Cheese.__dict__
False
>>> print ‘weight’ in Stilton.__dict__
False
>>> print ‘weight’ in stilton.__dict__
True

不管__init__()是在哪儿定义的,
stilton.__dict__与类的__dict__都无关。
Cheese.weight和Stilton.weight都会出错,因为这两个都碰不到实例的命名空间。而
stilton.weight的查找顺序是stilton.__dict__ =>
Stilton.__dict__ =>
Cheese.__dict__ => object.__dict__.
这与Stilton.taste的查找顺序非常相似,仅仅是
在最前面多出了一步。

方法稍微复杂些。

复制代码 代码如下:

>>> print Cheese.__dict__[‘get_weight’]

>>> print Cheese.get_weight

>>> print stilton.get_weight
<__main__.Stilton object at 0x7ff820669190>>

我们可以看到点运算符把function变成了unbound method.
直接调用类命名空间的函数和点
运算返回的未绑定方法会得到不同的错误:

复制代码 代码如下:

>>> Cheese.__dict__[‘get_weight’]()
Traceback (most recent call last):
  File “”, line 1, in
TypeError: get_weight() takes exactly 1 argument (0 given)
>>> Cheese.get_weight()
Traceback (most recent call last):
  File “”, line 1, in
TypeError: unbound method get_weight() must be called with Cheese
instance as
first argument (got nothing instead)

但这两个错误说的是一回事,实例方法需要一个实例。所谓“绑定方法”就是简单地在调用方法时把一个实例对象作为第一个参数。下面这些调用方法是等价的:

复制代码 代码如下:

>>> Cheese.__dict__[‘get_weight’](stilton)
‘100g’
>>> Cheese.get_weight(stilton)
‘100g’
>>> Stilton.get_weight(stilton)
‘100g’
>>> stilton.get_weight()
‘100g’

最后一种也就是平常用的调用方式,stilton.get_weight(),是点运算符的另一种功能,将stilton.get_weight()翻译成stilton.get_weight(stilton).
这样,方法调用实际上有两个步骤。首先用属性查找的规则找到get_weight,
然后将这个属性作为函数调用,并把实例对象作为第一参数。这两个步骤间没有联系。比如说你可以这样试:

复制代码 代码如下:

>>> stilton.weight()
Traceback (most recent call last):
  File “”, line 1, in
TypeError: ‘str’ object is not callable

先查找weight这个属性,然后将weight做为函数调用。但weight是字符串,所以出错。要注意在这里属性查找是从实例开始的:

复制代码 代码如下:

>>> stilton.get_weight = lambda : ‘200g’
>>> stilton.get_weight()
‘200g’

但是

复制代码 代码如下:

>>> Stilton.get_weight(stilton)
‘100g’

Stilton.get_weight的查找跳过了实例对象stilton,所以查找到的是没有被覆盖的,在Cheese中定义的方法。

getattr(stilton,
‘weight’)和stilton.weight是等价的。类对象和实例对象没有本质区别,getattr(Cheese,
‘smell’)和Cheese.smell同样是等价的。getattr()与点运算符相比,好处是属性名用字符串指定,可以在运行时改变。

__getattribute__()是最底层的代码。如果你不重新定义这个方法,object.__getattribute__()和type.__getattribute__()就是getattr()的具体实现,前者用于实例,后者用以类。换句话说,stilton.weight就是object.__getattribute__(stilton,
‘weight’). 覆盖这个方法是很容易出错的。比如说点运算符会导致无限递归:

复制代码 代码如下:

def __getattribute__(self, name):
        return self.__dict__[name]

__getattribute__()中还有其它的细节,比如说descriptor
protocol的实现,如果重写很容易搞错。

__getattr__()是在__dict__查找没找到的情况下调用的方法。一般来说动态生成属性要用这个,因为__getattr__()不会干涉到其它地方定义的放到__dict__里的属性。

复制代码 代码如下:

>>> class Cheese(object):
…     smell = ‘good’
…     taste = ‘good’

>>> class Stilton(Cheese):
…     smell = ‘bad’
…     def __getattr__(self, name):
…         return ‘Dynamically created attribute “%s”‘ % name

>>> stilton = Stilton()
>>> print stilton.taste
good
>>> print stilton.weight
Dynamically created attribute “weight”
>>> print ‘weight’ in stilton.__dict__
False

由于方法只不过是可以作为函数调用的属性,__getattr__()也可以用来动态生成方法,但同样要注意无限递归:

复制代码 代码如下:

>>> class Cheese(object):
…     smell = ‘good’
…     taste = ‘good’
…     def __init__(self, weight):
…         self.weight = weight

>>> class Stilton(Cheese):
…     smell = ‘bad’
…     def __getattr__(self, name):
…         if name.startswith(‘get_’):
…             def func():
…                 return getattr(self, name[4:])
…             return func
…         else:
…             if hasattr(self, name):
…                 return getattr(self, name)
…             else:
…                 raise AttributeError(name)

>>> stilton = Stilton(‘100g’)
>>> print stilton.weight
100g
>>> print stilton.get_weight

>>> print stilton.get_weight()
100g
>>> print stilton.age
Traceback (most recent call last):
  File “”, line 1, in
  File “”, line 12, in __getattr__
AttributeError: age

希望本文所述对大家的Python程序设计有所帮助。

本文实例分析了Python中的对象,方法,类,实例,函数用法。分享给大家供大家…

Python函数中的函数(闭包)用法实例,python函数

本文实例讲述了Python闭包的用法。分享给大家供大家参考,具体如下:

Python函数中也可以定义函数,也就是闭包。跟js中的闭包概念其实差不多,举个Python中闭包的例子。

def make_adder(addend):
  def adder(augend):
    return augend + addend
  return adder
p = make_adder(23)
q = make_adder(44)
print(p(100))
print(q(100))

运行结果是:123和144.

为什么?Python中一切皆对象,执行p(100),其中p是make_adder(23)这个对象,也就是addend这个参数是23,你又传入了一个100,也就是augend参数是100,两者相加123并返回。

有没有发现make_adder这个函数,里面定义了一个闭包函数,但是make_adder返回的return却是里面的这个闭包函数名,这就是闭包函数的特征。

再看一个Python闭包的例子:

def hellocounter (name):
  count=[0]
  def counter():
    count[0]+=1
    print('Hello,',name,',',count[0],' access!')
  return counter
hello = hellocounter('ma6174')
hello()
hello()
hello()

运行结果:

tantengdeMacBook-Pro:learn-python tanteng$ python3 closure.py 
Hello, ma6174 , 1 access!
Hello, ma6174 , 2 access!
Hello, ma6174 , 3 access!

使用闭包实现了计数器的功能,这也是闭包的一个特点,返回的值保存在了内存中,所以可以实现计数功能。

转自:小谈博客

希望本文所述对大家Python程序设计有所帮助。

python简单的函数定义和用法实例,python函数实例

本文实例讲述了python简单的函数定义和用法。分享给大家供大家参考。具体分析如下:

这里定义了一个温度转换的函数及其用法。

def convertTemp(temp, scale):
  if scale == "c":
   return (temp - 32.0) * (5.0/9.0)
  elif scale == "f":
   return temp * 9.0/5.0 + 32
temp = int(input("Enter a temperature: "))
scale = input("Enter the scale to convert to: ")
converted = convertTemp(temp, scale)
print("The converted temp is: " + str(converted))

希望本文所述对大家的Python程序设计有所帮助。

本文实例讲述了python简单的函数定义和用法。分享给大家供大家参考。具体分析如下:
这…

Python函数嵌套实例,python函数嵌套

在Python中函数可以作为参数进行传递,而也可以赋值给其他变量(类似Javascript,或者C/C++中的函数指针);

类似Javascript,Python支持函数嵌套,Javascript嵌套函数的应用模式对Python适用;

复制代码 代码如下:

>>> def multiplier(factor):
… def multiple(number):
… return number * factor
… return multiple

>>>
>>> multiplier(3)(3)
9
>>> multiplier(4)(3)

与嵌套函数紧密相关的就是闭包特性,举一个简单的例子:

复制代码 代码如下:

>>> def test():
… a = {‘name’: ‘wyj’}
… def f():
… return a[‘name’]
… return f

>>> def test():
… a = {‘name’: ‘wyj’}
… def f():
… return a[‘name’]
… return a,f

>>> a,f = test()
>>> f()
‘wyj’
>>> a[‘name’] = ‘ljq’
>>> f()
‘ljq’

Python可变参数函数用法实例,python可变参数实例

本文实例讲述了Python可变参数函数用法。分享给大家供大家参考。具体如下:

#!/usr/bin/python
def f1(a,b): print a,b
def f2(a,*b): print a,b
def f3(a,**b): print a,b
def f4(a,*b,**c): print a,b,c
def f5(a,b=2,c=3): print a,b,c
def f6(a,b=2,*c): print a,b,c
f1(1,2)
f1(b=2,a=1)
f2(1,2,3,4)
f3(1,x=2,y=3,z=4)
f4(1,x=2,y=3)
f5(1)
f5(1,4)
f6(1)
f6(1,3,4,5,4)

#!/usr/bin/python
def echoo(*args,**kwargs):
  print args,kwargs
echoo(1,2,a=3,b=4)
pargs = (1,2)
pkwargs = {'a':3,'b':4}
apply(echoo,pargs,pkwargs)

希望本文所述对大家的Python程序设计有所帮助。

本文实例讲述了Python可变参数函数用法。分享给大家供大家参考。具体如下:
#!/usr/bin/py…

您可能感兴趣的文章:

  • 简析Python的闭包和装饰器
  • 简单讲解Python中的闭包
  • 浅谈Python中的闭包
  • python中的闭包用法实例详解
  • Python闭包实现计数器的方法
  • Python编程中运用闭包时所需要注意的一些地方
  • 详解Python中的装饰器、闭包和functools的教程
  • Python、Javascript中的闭包比较
  • Python中的闭包详细介绍和实例
  • Python中的闭包总结
  • Python深入学习之闭包
  • Python中的闭包实例详解

本文实例讲述了Python闭包的用法。分享给大家供大家参考,具体如下:
Python函数中也可以定义…

对于python 函数嵌套

因为最后的那句return nested。

tester()()会自动调用它的返回值,而此时的返回值为nested,即def
nested()这个函数,所以自然而然执行到了里面的print语句。
你可以试试把最后那就return nested改成其他的如return
nestedxxx,再tester()()时就会报错了。
另外,在python里对于方法ester和nested是没有tester().nested()这种用法的,所以这样输入肯定报错的,如果ester和nested是类(class)的话才有这种写法。

希望对你有所帮助~~
 

python 里面类的__init__函数可以嵌套别的函数?

当然可以,查一下 “闭包 ”
 

在Python中函数可以作为参数进行传递,而也可以赋值给其他变量(类似Javascript,或者C/C++中的函数指针)…

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图