python进级(4) getattr的用法

by admin on 2019年11月18日

getattr()这个方法最主要的作用是实现反射机制。也就是说可以通过字符串获取方法实例。  传入不同的字符串,调用的方法不一样。

问题聚焦:

看了下函数本身的doc

  1. abs(x)

python 内建函数

列表:

a.append   a.count    a.extend   a.index    a.insert   a.pop    
 a.remove   a.reverse  a.sort

 

a = [1, 3, 3, 2]

 

  1. a.append     L.append(object) — append object to end   

 

In [6]:a.append(‘qing’)    
添加一个对象(字符串,字典,元组等),每次只能添加一个值

In [8]: a

Out[8]: [1, 3, 3, 2, ‘qing’]

 

  1. a.count     L.count(value) -> integer — return number of
    occurrences of value   

   

   In [14]: a.count(3)     查看有没有‘3’ 这个值以及数量

   Out[14]: 2

   

  1. a.extend     L.extend(iterable) — extend list by appending elements
    from the iterable

 

In [23]: a.extend(‘qing’)    将字符串拆封成单个的字符串

   In [24]: a

   Out[24]: [1, 3, 3, 2, ‘qing’, ‘q’, ‘i’, ‘n’, ‘g’]

   In [313]: a.extend([‘why’,’not’])

   Out[314]: [1, 2, 3, ‘apple’ ‘why’, ‘not’]

   

  1. a.index      L.index(value, [start, [stop]]) -> integer —
    return first index of value.

                Raises ValueError if the value is not present.

   

   In [35]: a

   Out[35]: [1, 3, 3, 2, ‘qing’, ‘q’, ‘i’, ‘n’, ‘g’]

   In [36]: a.index(‘qing’)     查看字符串qing
所在的位置,从0开始计数,返回第一个查询到的值

   Out[36]: 4

   

  1. a.insert  
    L.insert(index, object) — insert object before index

 

   Out[44]: [1, 3, 3, 2, ‘qing’, ‘q’, ‘i’, ‘n’, ‘g’]  

   

In [46]: a.insert(1,’liang’)       在第二个位置插入字符串liang

   Out[47]: [1, ‘liang’, 3, 3, 2, ‘qing’, ‘q’, ‘i’, ‘n’, ‘g’]

 

6  a.pop    
L.pop([index]) -> item — remove and return item at index
(default last).

           
Raises IndexError if list is empty or index is out of range.

                 

In [55]: a

Out[55]: [1, ‘liang’, 3, 3, 2, ‘qing’, ‘q’, ‘i’, ‘n’]

In [56]: a.pop()           按位置删除列表, 为空
,默认删除最后一个参数   

Out[56]: ‘n’

In [58]: a.pop(-1)        -1 为倒数第一个, -2倒数第二个, 正数从0开始

    Out[58]: ‘i’

    In [59]: a.pop(2) 

    Out[59]: 3

    

    

  1. a.remove
    L.remove(value) — remove first occurrence of value.

             
Raises ValueError if the value is not present.

             

    In [70]: a

Out[70]: [1, ‘liang’, 2]

In [71]: a.remove(‘liang’)  按列表中的内容删除 

In [72]: a

Out[72]: [1, 2]

 

  1. a.reverse
    L.reverse() — reverse *IN PLACE*

                                   

   In [79]: a                      

   Out[79]: [1, 2, ‘liang’, ‘ming’]

   In [81]: a.reverse()        将字符串倒着排序                      
             

   In [82]: a                      

   Out[82]: [‘ming’, ‘liang’, 2, 1]

   

   

  1. a.sort     L.sort(cmp=None, key=None, reverse=False) — stable sort
    *IN PLACE*;

              cmp(x, y) -> -1, 0, 1              

              

   In [100]: a                                                        
       

   Out[100]: [1, 2, ‘liang’, ‘ming’, ‘apple’]                      
                   

   In [101]: a.sort()          按1234,abcd排序 ,数字优先            
                                          

   In [102]: a                               

   Out[102]: [1, 2, ‘apple’, ‘liang’, ‘ming’]

   

   

   

   

字典;  

qing.clear       qing.fromkeys    qing.has_key     qing.iteritems  
qing.itervalues  qing.pop         qing.setdefault  qing.values    
 qing.viewkeys  

qing.copy        qing.get         qing.items       qing.iterkeys  
 qing.keys        qing.popitem     qing.update      qing.viewitems  
qing.viewvalues

 

 

qing = {‘liang’:’ming’,’qing’:’fanqin’ } 

 

  1. qing.clear    D.clear() -> None.  Remove all items from D.      

 

In [130]: qing                               

Out[130]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’}

In [133]: qing.clear()        清空字典                 

In [134]: qing        

Out[134]: {}          

 

  1. qing.fromkeys   dict.fromkeys(S[,v]) -> New dict with keys from
    S and values equal to v.

                 
 函数用于创建一个新字典,以序列S中元素做字典的键,value为字典所有键对应的初始值。

   In [152]: a                                               

   Out[152]: [1, 2, 3, ‘apple’, ‘big’, ‘hi’, ‘liang’, ‘ming’]

                                                          

   In [153]: qing                                            

   Out[153]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’}   

                                          

   In [155]: qing.fromkeys(a)   将列表a的参数当做字典的key,没有指定
, 默认value所以值为none

   Out[155]:                    

   {1: None, 2: None, 3: None,  ‘apple’: None,’big’: None, ‘hi’: None,
‘liang’: None, ‘ming’: None}               

                             

   In [156]: qing.fromkeys(a,10)   

   Out[156]: {1: 10, 2: 10, 3: 10,’apple’: 10,’big’: 10,’hi’:
10,’liang’: 10,’ming’: 10}    

 

 

  1.  qing.has_key         D.has_key(k) -> True if D has a key k,
    else False 

     

    In [159]: qing

    Out[159]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’} 

    In [161]: qing.has_key(‘liang’)     判断字典中是否有key–liang  
若有返回True 否则 False

    Out[161]: True

    

    

  1. qing.pop  
    D.pop(k[,d]) -> v, remove specified key and return the
    corresponding value.

If key is not found, d is returned if given, otherwise KeyError is
raised

 

In [167]: qing

Out[167]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’}

In [168]: qing.pop(‘liang’)      删除字典中的key,value,
因为key值唯一,所以不用写value

Out[168]: ‘ming’

In [169]: qing

Out[169]: {‘qing’: ‘fanqin’}

 

  1. qing.setdefault   D.setdefault(k[,d]) -> D.get(k,d), also set
    D[k]=d if k not in D

In [169]: qing

Out[169]: {‘qing’: ‘fanqin’}

In [174]: qing.setdefault(‘qing’)     如果存在qing这个key
则直接返回结果

Out[174]: ‘fanqin’

In [175]: qing.setdefault(‘liang’)    如果不存在liang这个key
 则将liang 当做key,直接添加到字典中,若不指定value,则为None

In [176]: qing

Out[176]: {‘liang’: None, ‘missyou’: None, ‘qing’: ‘fanqin’}

In [182]: qing.setdefault(‘qin’,’sf’)     若不存在qing这个key
这将key,value直接插入到字典中                                          
                                                                       
                                                                       
                                                                       
                 

    Out[183]: {‘liang’: None, ‘missyou’: None, ‘qin’: ‘sf’, ‘qing’:
‘fanqin’}

    

  1. qing.values()   D.values() -> list of D’s values

                                                

   In [187]: qing.values()      列出字典qing中所有的value值          
     

   Out[187]: [‘ele’, ‘fanqin’, ‘ming’]

   

  1. qing.keys()     D.keys() -> list of D’s keys

   

   In [193]: qing.keys()         列出所有的key值                      
       

   Out[193]: [‘ting’, ‘qing’, ‘liang’]

   

  1. qing.items()    D.items() -> list of D’s (key, value) pairs, as
    2-tuples

                                                                     

   In [214]: qing.items()      以元组的形式列出字典中所有的内容      
                               

   Out[214]: [(‘ting’, ‘ele’), (‘qing’, ‘fanqin’), (‘liang’,
‘ming’)]

   

  1. qing.viewvalues
    D.viewvalues() -> an object providing a view on D’s values

    

    In [215]: qing.viewvalues()                     

    Out[215]: dict_values([‘ele’, ‘fanqin’, ‘ming’])

    

  1. qing.viewkeys
    D.viewkeys() -> a set-like object providing a view on D’s keys

 

In [218]: qing.viewkeys()                    

    Out[218]: dict_keys([‘ting’, ‘qing’, ‘liang’]

    

  1. qing.viewitems() D.viewitems() -> a set-like object
    providing a view on D’s items

In [220]: qing.viewitems()                                            
       

    Out[220]: dict_items([(‘ting’, ‘ele’), (‘qing’, ‘fanqin’),
(‘liang’, ‘ming’)])

    

    

  1. qing.copy    D.copy() -> a shallow copy of D

    

    In [224]: ming=qing.copy()        复制字典                        
                                                            

    In [225]: ming                                              

    Out[225]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’, ‘ting’: ‘ele’}

    

  1. qing.get
    D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to
    None.

 

In [227]: qing                                              

    Out[227]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’, ‘ting’: ‘ele’}      
                                                    

    In [228]: qing.get(‘ting’)   查询ting 对应的value值              
                

    Out[228]: ‘ele’        

    In [233]: qing.get(‘what’)    当key不存在是 没有返回或者为none    
                                                

    In [234]:  

    

  1. qing.popitem
    D.popitem() -> (k, v), remove and return some (key, value)
    pair as a 2-tuple; but raise KeyError if D is empty.

In [240]: qing                                               

    Out[240]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’, ‘ting’: ‘ele’} In 

    In [241]: qing.popitem()     为空, 默认删除最后一个

    Out[241]: (‘ting’, ‘ele’)

             

  1. qing.update  D.update([E, ]**F) -> None.  Update D from
    dict/iterable E and F.         

                 If E present and has a .keys() method, does:     for k
in E: D[k] = E[k]  

                 If E present and lacks .keys() method, does:     for
(k, v) in E: D[k] = v

              In either case, this is followed by: for k in F: D[k] =
F[k]              

  

 In [261]: qing                                                

    Out[261]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’}                    
                                                        

    In [262]: ting = {‘why’:’boring’}                                
                                                       

    In [263]: qing.update(ting)   字典qing中没有字典ting的key值时
 直接添加                                                              
                           

    In [264]: qing                                                

    Out[264]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’, ‘why’: ‘boring’}

    

    

    In [274]: qing                                                

    Out[274]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’, ‘why’: ‘boring’}    
                                                        

    In [275]: ting                                                

    Out[275]: {‘why’: ‘ele’}                                          
                                                     

    In [276]: qing.update(ting)                                      
                                                       

    In [277]: qing            字典qing中有字典ting的key值时   ,
直接修改                                 

    Out[277]: {‘liang’: ‘ming’, ‘qing’: ‘fanqin’, ‘why’: ‘ele’}   

    

    

    

    

元组:  

  1.  ting.count     T.count(value) -> integer — return number of
    occurrences of value

In [298]: ting = (‘a’,’b’,’c’)                            

    In [303]: ting.count(‘b’)

    Out[303]: 1              

    

  1.  ting.index
    T.index(value, [start, [stop]]) -> integer — return
    first index of value

    In [306]: ting.index(‘c’)

    Out[306]: 2             

    

    

字符串:

 

a.isdigit(                      a.rsplit(

a.islower(                      a.rstrip(

a.isspace(                      a.split(

a.capitalize(                   a.istitle(                    
 a.splitlines(

a.center(                       a.isupper(                    
 a.startswith(

a.count(                        a.join(                         a.strip(

a.decode(                       a.ljust(                      
 a.swapcase(

a.encode(                       a.lower(                        a.title(

a.endswith(                     a.lstrip(                      
a.translate(

a.expandtabs(                   a.partition(                    a.upper(

a.find(                         a.replace(                      a.zfill(

a.format(                       a.rfind(                        

a.index(                        a.rindex(                       

a.isalnum(                      a.rjust(                        

a.isalpha(                      a.rpartition(    

 

qing = ‘lot of Yihan For You

  1. str.count()  //返回该字符串中某个子串出现的次数

>>> qing

‘lot of Yihan For You’

>>> qing.count(‘o’)

4

 

  1. str.find()   //返回某个子串出现在该字符串的起始位置

>>> qing.find(“Y”)

 

  1. str.lower()  //将该字符串全部转化为小写

>>> qing.lower()

‘lot of yihan for you’

 

  1. str.upper()  //转为大写

>>> qing.upper()

‘LOT OF YIHAN FOR YOU’

 

  1. len(str)     //返回字符串长度

>>> len(qing)

20

 

6.S.swapcase() #大小写互换 

 >>> qing.swapcase()

‘LOT OF yIHAN fOR yOU’

 

  1. >>> qing.capitalize()   将首字母大写

‘Lot of yihan for you

 

  1.  name.split   将字符串拆分成列表的形式, 默认为空格

>>> name.split(“‘”)

[‘what’, ‘s your name’]  

 

  1. str.join   

>>> ming

[‘what’, ‘s your name’]

>>> ‘|’.join(ming)

‘what|s your name’

>>> 

 

文件 file

 

f = file(‘/qing/qing.txt’)

 

f.close(             f.isatty(            f.readinto(        
 f.truncate(

f.closed             f.mode               f.readline(          f.write(

f.encoding           f.name               f.readlines(        
f.writelines(

f.errors             f.newlines           f.seek(            
 f.xreadlines(

f.fileno(            f.next(              f.softspace           f.flush(
           

f.read(              f.tell(    

 

  1.  f.read()  将整个文件读出来,并以字符串的形式显示

              ‘lalalani dong de \nni dong de
\nsdfsd\nsfsfafsdfasfasdfsdfssssssssssssss\nllll\n’

              

  1. f.readlines()  将整个文件读出来, 并以列表的形式显示

              [‘lalalani dong de \n’, ‘ni dong de \n’, ‘sdfsd\n’,
‘sfsfafsdfasfasdfsdfssssssssssssss\n’, ‘llll\n’]

              

  1.  f.readline()  一行一行读,以字符串的形式显示     

     
>>> f.readline()

‘lalalani dong de \n’

>>> f.readline()

‘ni dong de \n’

  1.  f.mode

    ‘r’

    

  1. f.name

‘/qing/qing.txt’

 

  1.  f.next()    同f.readline()一样,
    只是在读取到最后一行以后会报错,而readline()不会报错

    ‘llll\n’

     f.next()

Traceback (most recent call last):

  File “<stdin>”, line 1, in <module>

StopIteration   

>>> f.readline()

 

  1. >>> f.seek(0)  
    跳到文件的指定字符位置,一般用作跳到文件开头的作用

>>> f.tell()       显示文件当前位置

0

>>> f.seek(10)

 

  1. f.truncate()  删除字符,与当前位置无关,以开始位置计数, 默认字节

 

 f = file(‘/qing/qing.txt’,’r+’)   以读写模式打开

     f.readlines()

    [‘lalalani dong de \n’, ‘ni dong de \n’, ‘sdfsd\n’,
‘sfsfafsdfasfasdfsdfssssssssssssss\n’, ‘llll\n’]

    >>> f.truncate(20)

     f.readlines()

   [‘lalalani dong de \n’, ‘ni’]

 

9. 

 

内建函数 列表: a.append a.count a.extend
a.index a.insert a.pop a.remove a.reverse a.sort a = [1, 3, 3, 2] 1.
a.append L.append(object) — append object to end In [6…

原型:getattr(对象,方法名)

熟悉getattr的应该知道,getattr(a, ‘b’)的作用就和a.b是一样的

那么这个内建函数有什么作用呢,最方便的无疑是使用它来实现工厂方法(Factory
Method)模式

另外,在回调函数里也经常使用这个函数,对回调理解不深,这里不再举例

复制代码 代码如下:

abs()函数返回数字(可为普通型、长整型或浮点型)的绝对值。如果给出复数,返回值就是该复数的模。例如:

 

先看一下官方文档:

getattr(object, name[, default]) -> value

>>>print abs(-2,4)

举个栗子:

getattr(object, name[, default])

Get a named attribute from an object; getattr(x, ‘y’) is equivalent to
x.y.
When a default argument is given, it is returned when the attribute
doesn’t
exist; without it, an exception is raised in that case.

2.4

pyMethod类下定义了三个方法,getattr(pyMethod(),’out%s’%str)()  
传入的方法名不同,调用不同的方法。些处方法名为字符串。

Return the value of the named attribute of object. name must be a
string. If the string is the name of one of the object’s attributes, the
result is the value of that attribute. For example, getattr(x, ‘foobar’)
is equivalent to x.foobar. If the named attribute does not exist,
defaultis returned if provided, otherwise AttributeError is raised.

解释的很抽象 告诉我这个函数的作用相当于是

>>>print abs(4+2j)

这样的话,想想是不是用途很多,我可以把方法名配置到文件中,读取时使用getattr动态去调用。

参数说明:

object.name

4.472135955

#coding=utf-8

class pyMethod(object):
    def outstr(self):
        print('this is string')

    def outint(self):
        print('this is number')

    def outdate(self):
        print('this is date')


if __name__=="__main__":
    str = 'int'
    getattr(pyMethod(),'out%s'%str)()     
    str = 'str'
    getattr(pyMethod(),'out%s'%str)()
    str = 'date'
    getattr(pyMethod(),'out%s'%str)()

试了一下getattr(object,name)确实和object.name是一样的功能.只不过这里可以把name作为一个变量去处理书上的例子很好的说明了这个函数的功用,使用getattr可以轻松实现工厂模式。

  1. apply(function,args[,keywords])

 

try:
    func = getattr(obj, "method")
except AttributeError:
    ...... deal
else:
    result = func(args)

// 或指定默认返回值
func = getattr(obj, "method", None)
if func:
    func(args)

例:一个模块支持html、text、xml等格式的打印,根据传入的formate参数的不同,调用不同的函数实现几种格式的输出

apply()函数将args参数应用到function上。function参数必须是可调用对象(函数、方法或其他可调用对象)。args参数必须以序列

 getattr(pyMethod(),'out%s'%str)()  注意pyMethod()和最后的()   这里之所以这么写pyMethod()加括号是实例化类对象,最后的括号,因为getattr函数反射后,是一个方法对象。

TypeError: 不可调用

复制代码 代码如下:

形式给出。列表在应用之前被转换为元组。function对象在被调用时,将args列表的内容分别作为独立的参数看待。例如:

 

func = getattr(obj, "method", None)
if callable(func):
    func(args)

import statsout
def output(data, format=”text”):                          
    output_function = getattr(statsout, “output_%s” %format)
    return output_function(data)
[code]
这个例子中可以根据传入output函数的format参数的不同
去调用statsout模块不同的方法(用格式化字符串实现output_%s)

apply(add,(1,3,4))

运行结果:

用getattr实现工厂方法:

返回的是这个方法的对象 就可以直接使用了 如果要添加新的格式
只需要在模块中写入新的方法函数
在调用output函数时使用新的参数就可以使用不同的格式输出

等价于

C:\Python27\python.exe D:/weixin/python_getattr.py
this is number
this is string
this is date

Process finished with exit code 0

Demo:一个模块支持html、text、xml等格式的打印,根据传入的formate参数的不同,调用不同的函数实现几种格式的输出

确实很方便

add(1,3,4)

 

import statsout 
def output(data, format="text"):                           
    output_function = getattr(statsout, "output_%s" %format) 
    return output_function(data)

为了加深对getattr函数的理解 转载一篇英文的说明

在以列表或元组定义了一列参数,且需要将此列表参数分别作为个个独立参数使用的情况下,必须使用apply()函数。在要把变长参数列

Linux and
python学习交流1,2群已满.

这个例子中可以根据传入output函数的format参数的不同
去调用statsout模块不同的方法(用格式化字符串实现output_%s)

Python’s getattr function is used to fetch an attribute from an object,
using a string object instead of an identifier to identify the
attribute. In other words, the following two statements are equivalent:

应用到已函数上时,apply()函数非常有用。

Linux and
python学习交流3群新开,欢迎加入,一起学习.qq 3群:563227894

参考资料:

[code]
value = obj.attribute
value = getattr(obj, “attribute”)
If the attribute exists, the corresponding value is returned. If the
attribute does not exist, you get an AttributeError exception instead.

可选项keywords参数应是个字典,字典的关键字是字符串。这些字符串在apply()函数的参数列末尾处给出,它们将被用作关键字参数。

不前进,不倒退,停止的状态是没有的.

Python找那个的getattr()函数详解

The getattr function can be used on any object that supports dotted
notation (by implementing the __getattr__ method). This includes
class objects, modules, and even function objects.

  1. buffer(object[,offset[,size]])

一起进步,与君共勉,

python2.7文档

path = getattr(sys, “path”)
doc = getattr(len, “__doc__”)
The getattr function uses the same lookup rules as ordinary attribute
access, and you can use it both with ordinary attributes and methods:

如果object对象支持缓存调用接口buffer()函数就为object对象创建一个新缓存。这样的对象包括字符串、数组和缓存。该新缓存通过使

熟悉getattr的应该知道,getattr(a,
‘b’)的作用就和a.b是一样的
那么这个内建函数有什么作用呢,最方便的无疑是使用它来实现工厂…

result = obj.method(args)

用从offset参数值开始知道该对象末尾的存储片段或从offset参数值开始直到size参数给出的尺寸为长度的存储片段来引用object对象。如果

func = getattr(obj, “method”)
result = func(args)
or, in one line:

没给出任何选项参数,缓存区域就覆盖整个序列,最终得到的缓存对象是object对象数据的只读拷贝。

result = getattr(obj, “method”)(args)
Calling both getattr and the method on the same line can make it hard to
handle exceptions properly. To avoid confusing AttributeError exceptions
raised by getattr with similar exceptions raised inside the method, you
can use the following pattern:

缓存对象用于给某个对象类型创建一个更友好的接口。比如,字符串对象类型通用缓存对象而变得可用,允许逐个字节地访问字符串中的信息。

try:
    func = getattr(obj, “method”)
except AttributeError:
    … deal with missing method …
else:
    result = func(args)
The function takes an optional default value, which is used if the
attribute doesn’t exist. The following example only calls the method if
it exists:

  1. callable(object)

func = getattr(obj, “method”, None)
if func:
    func(args)
Here’s a variation, which checks that the attribute is indeed a callable
object before calling it.

callable()函数在object对象是可调用对象的情况下,返回真(true);否则假(false),可调用对象包括函数、方法、代码对象、类(在调用时返回新的实例)和已经定义‘调用’方法的类实例

func = getattr(obj, “method”, None)
if callable(func):
    func(args)

  1. chr(i)

复制代码 代码如下:
getattr(object, name[, default]) – value Get a named attribute from an
object; getattr(x, ‘y’) is equivalent to x.y. When a d…

chr()函数返回与ASCII码i相匹配的一个单一字符串,如下例所示:

>>>print chr(72)+chr(101)+chr(108)+chr(111)

hello

chr()函数是ord()函数的反函数,其中ord()函数将字符串转换回ASCII整数码,参数i的取值应在0~255范围内。如果参数i的取值在此范围之外,将引发ValueError异常。

  1. cmp(x,y)

cmp()函数比较x和y这两个对象,且根据比较结果返回一个整数。如果xy,则返回正数。请注意,此函数特别用来比较数值大小,而不是任何引用关系,因而有下面的结果:

>>>a=99

>>>b=int(’99’)

>>>cmp(a,b)

0

  1. coerce(x,y)

coerce()函数返回一个元组,该元组由两个数值型参数组成。此函数将两个数值型参数转换为同一类型数字,其转换规则与算术转换规则一样。一下是两个例子:

>>>a=1

>>>b=1.2

>>>coerce(a,b)

(1.0,1.2)

>>>a=1+2j

>>>b=4.3e10

>>>coerce(a,b)

((1+2j),(43000000000+0j))

  1. compile(string,filename,kind)

compile()函数将string编译为代码对象,编译生成的代码对象接下来被exec语句执行,接着能利用eval()函数对其进行求值。filename参数应是代码从其中读出的文件名。如果内部生成文件名,filename参数值应是相应的标识符。kind参数指定string参数中所含代码的类别,有关kind可能取值的详细信息,请参见表8-1

举例如下:

>>>a=compile(‘print “Hello World”’,’’,’single’)

>>>exec(a)

Hello World

>>>eval(a)

Hello World

表 由compile()函数编译的代码的类别

Kind取值编译生成的代码

exec语句序列

eval简单表达式

Single简单交互语句

  1. complex(real,[image])

Complex()函数返回一个复数,其实部为real参数值。如果给出image参数的值,则虚部就为image;如果默认image参数,则虚部为0j。

  1. delattr(object,name)

delattr()函数在object对象许可时,删除object对象的name属性,此函数等价于如下语句:

del object.attr

而delattr()函数允许利用编程方法定义来定义object和name参数,并不是在代码中显示指定。

  1. dir([object])

当没有提供参数时,dir()函数列出在当前局部符号表中保存的名字,如下例所示:

>>>import sys

>>>dir(sys)

  1. divmod(a,b)

devmod()函数返回一个元组,该元组包含a除以b的商和余数,如下例所示:

>>>divmod(7,4)

(1,3)

对整数而言,返回值与a/b和a%b相同。如果给出的参数值是浮点数,则结果就是(q,a%b),其中:q通常是math.floor(a/b),但是也可能比这小1,不管在什么情况下,q*b+a%b都非常逼近a;如果a%b是个非零值,则其正负号与b相同,并且有0<=abs(a%b)

>>>divmod(3.75,1.125)

(3.0,0.375)

>>>divmod(4.99,1.001)

(4.0,0.98600000000000065)

>>>divmod(-3.5,1.1)

(-4.0,0.90000000000000036)

  1. eval(expression[,global[,locals]])

eval()函数将expression字符串作为python标准表达式进行分析并求值,返回expression字符串的值,当不可调用其他可选参数时,expression访问调用该函数的程序段的全局和局部对象。另一个选择是:以字典形式给出全局和局部符号表(参见后面部分对global()和local()函数的论述)。

Eval()函数的返回值是被求职表达式的值,如下例所示:

>>>a=99

>>>eval(‘divmod(a,7)’)

(14,1)

任何求值操作的语法错误,都将引发成异常

eval()函数还能用来编译诸如由complie()函数创建的代码对象,但仅当该代码对象用“eval”模式编译过后才可用eval()函数编译。

要执行混合了语句和表达式的python任意代码,请使用exec语句或使用execfile()函数来动态地执行含有任意代码的文件。

14.execfile(file[,globals[,locals]])

execfile()函数与exec语句等价,不同之处在于:execfile()函数执行文件中的语句,而exec语句处理字符串。其中globals和locals参数应是字典,该字典包含文件在执行期间有效的符号表;如果locals参数省略,则所有的引用都使用globals名称空间。如果两个可选参数都省略,文件就访问运行期间的当前符号表。

15.filter(function,list)

filter()函数根据function参数返回的结果是否为真(true)来过滤list参数中的项,最后返回一个新列表,如下例所示:

a=[1,2,3, 4, 5,6,,7,8,9]

b=filter(lambda x:x>6,a)

print b

[7,8,9]

如果function参数值为None,就是用identity函数,list参数中的所有为假(false)的元素都被删除。

  1. flaot(x)

float()函数将x参数转换为浮点数,其中:x可以是字符串,也可以是数字。

  1. getattr(object,name[,default])

getattr()函数返回object的name属性值。在语法上,以下语句:

getattr(x,’myvalue’)

等价于

x.myvalue

如果name参数不存在,但给出defalut参数的值,则此函数就返回default参数值;否则引发AttributeError异常

  1. globals()

globals()函数返回一个表示当前全局符号表的字典。这个字典通常就是当前模块的字典。如果globals()函数是在一函数或方法中被调用,它就返回定义该函数或方法的模块的符号表,而不是调用此函数的模块的符号表。

  1. hasattr(object,name)

如果object对象具有与name字符串相匹配的属性,hasattr()函数返回真(true);否则返回0。

  1. hash(object)

hash()函数返回关于object对象的整数散列值。如任何两个对象比较起来是等价的,则它们的散列值是一样的。此函数不应用于可便对向上。

21.hex(x)

hex()函数将一整数转换为十六进制字符串,该字符串是个有效的python表达式、

  1. id(object)

id()函数返回值为一个整数(或长整型整数)——该对象的“标识“——该标识在其对应对象的生命期内,确保是唯一的和恒定不变的。

  1. input([prompt])

input()函数与eval(raw_input(prompt))等价。

  1. int(x,[radix])

int()函数将使数字或字符串x转换为“普通”整数。如果给出radix参数的值,则radix参数值用作转换的基数,该参数应是2~36范围内的一个整数。

  1. intern(string)

intern()函数将string加入到保留字符串的表,返回值为保留的版本号。“保留字符串”通过指针可用,而不是一个纯的字符串;因此允

许利用指针比较代替字符串比较来进行字典关键字的查找,这比通常的字符串比较方法功能有所改善。

在python名称空间表和用于保留模块、类或实力属性的字典中使用的名字通常被保留用以加速脚本执行。

保留字符串定义后不能被作为无用单元收集,所以必须注意在大字典关键字集上使用保留字符串将大大增加内存需求,即使字典关键字应急超出了作用域。

  1. isinstance(object,class)

isinstance()函数在object参数是class参数的一个实例时,返回真。函数值的确定服从普通继承法则和子类。如果object参数是在types模块中利用类型类定义的特殊类型的实例,也能用isinstance()函数来识别。如果class参数不是类,也不是类型对象,就引发TypeError异常

27.issubclass(class1,class2)

如果class1参数是class2参数的子类,issubclass()函数则返回真。类通常被认为是其自身的子类。若两个参数中任一个都不是类对象,则引发TypeError异常

  1. len(s)

len()函数返回一序列(字符串、元组或列表)或字典对象的长度

29. list(sequence)

list()函数返回以列表。该列表的项及顺序与sequence参数的项及顺序相同,如下例所示:

>>>list(‘abc’)

[‘a’,’b’,’c’]

>>>list([1,2,3])

[1,2,3]

  1. locals()

locals()函数返回表示当前局部符号表的字典

  1. long(x)

long()函数将字符串或数字转换为长整型数,对浮点数的转换遵循与int()相同的规则

  1. map(function,list,…)

map()函数将function运用到list中的每一项上,并返回新的列表,如下例所示:

>>>a=[1,2,3,4]

>>>map(lambda x:pow(x,2),a)

[1,4,9,16]

若提供附加的列表,则它们就被并行地提供给function。在后续无元素的列表增加None,直到所有参数列表达到相同的长度为止。

如果function参数值为None,则假定为identify函数,将使map()函数返回删除所有为假的参数list。如果function参数值为None,且给定多个列表参数,返回的列表由一个个元组组成,这些元组由函数中的每一个参数列表内相同对应位置上的参数组成,如下例所示:

>>>map(None,[1,2,3,4],[4,5,6,7])

[(1,4),(2,5),(3,6),(4,7)]

上例的结果与zip()函数产生的结果等价

  1. max(s,[,args…])

当仅给定一个参数时,max()函数返回序列s的最大值。当给定一列参数时,max()函数返回给定参数的最大参数

  1. min(s[,args…])

当仅给定一个参数时,min()函数返回序列s的最小值。当给定一列参数时,min()函数返回给定参数中的最小值。记住:多参数调用的序列不被遍历,每个列表参数作为一个整体进行比较,如:

min([1,2,3],[4,5,6])

返回

[1,2,3]

而不是通常所想的结果为1,要得到一个或多个列表中元素的最小值,可将所有列表连成一串,如下所示:

min([1,2,3]+[4,5,6])

  1. oct(x)

该函数将整数转换为八进制字符串。其结果是个有效的python表达式,如下例所示:

>>>oct(2001)

‘03721’

请注意,返回值通常是无符号数。这样致使oct(-1)在32位机器上产生’037777777777’的结果

  1. open(filename[,mode[,bufsize]])

open()函数通过使用mode和缓存bufsize类型来打开filename标识的文件。此函数返一文件对象其中mode与系统函数fopen()使用的模式相同。如果mode参数省略,其默认取值为r

模式 含义

r打开用于读

w打开用于写

a打开用于附加(打开期间,文件位置自动移到文件末尾)

r+打开用于更新(读和写)

w+截断(或清空)文件,接着打开文件用于读写

a+打开文件用于读和写,并自动改变当前为止到文件尾

当附加任何模式选项时,以二进制模式而不是文本模式,打开文件(这种模式b仅对windows、dos和其他一些操作系统有效,对Unix、MacOS和BeOS则不管选项为何值,以二进制模式对待所有文件)

open()函数的bufsize选项参数决定从文件中读取数据时所使用的缓存的大小,如果bufsize省略,就使用系统默认的缓存容量

bufsize值 说明

禁用缓存

行缓存

>1使用大小近似为bufsize字符长度的缓存

<0使用系统默认

37.ord(c)

该函数返回由一个字符c组成的字符串的ASCII码值或Unicode数字码。ord()函数是chr()函数和nuichr()函数的反函数

38.pow(x,y[,z])

该函数返回以x为底数以y为指数的幂值。如果给出z,该函数就计算x的y次幂值被z取模的值,这样的计算比利用:pow(x,y)%z的效率更高提供给pow()函数的参数应是数值型,并且给定的类型决定返回值的类型。如果计算得出的数值不能用给定参数值的类型表示,则引发异常,

比如,以下对pow()的调用将失败:

pow(2,-1)

但是

pow(2.0,-1)

是有效的

  1. range([start,]stop[,step])

该函数返回数值列表,该数值列表从start开始,以step为步长,于stop之前结束。所有的数字都应列出,并且以普通整型数返回。如果step省略,则默认取1.如果start省略,则从0开始求值。如果以两个参数形式调用,则认作给定的参数是start和stop,如果要定义步长就必须给出全部的三个参数。下面对range()函数的调用使用了值为正数的步长step:

>>>range(5,25,5)

[5,10,15,20]

请注意,最后的数值是stop减去step,range()函数的返回值从小递增到大,趋近stop的值,但不包含stop这个值

如果step的给定值是负数,range()函数的返回值从大递增到小,而不是递增,stop必须比stop小;否则返回的列表为空。下列说明了step取值为负数的运用情况:

>>>range(10,0,-1)

[10,9,8,7,6,5,4,3,2,1]

>>>range(25,0,-5)

[25,20,15,10,5]

>>>range(0,10,-1)

[]

  1. raw_input([prompt])

该函数从sys.stdin接受原始输入并返回字符串。输入以换行符为结束,其中换行符在输入字符串返回给调用者之前被去除。如果给出prompt,末尾不含换行符的prompt就被写到sys.stdout中,并用作输入的提示,如下例所示:

>>>name=raw_input(‘Name?’)

Name?Martin

如果已加载readline模块,则诸如行编辑和历史记录的特性在输入期间就得到支持

  1. reduce(function,sequence[,initializer])

该函数一次应用function(支持两个函数)到sequence中的每个元素上,逐渐缩短整个语句直到为一个单一的值。举例,下面的语句模拟了算术运算符“!”:

reduce(lambda x,y:x*y,[1,2,3,4,5])

其结果如同执行以下计算一样:

((((1*2)*3)*4)*5)

结果等于120

如果给出initializer参数值,则initializer参数值就被用作序列的第一个元素,如下列所示:

>>>reduce(lambda x,y:x*y,[1,2,3,4,5],10)

1200

  1. reload(module)

reload()函数将以前导入过的模块再加载一次。重新加载(reload)包括最初导入模块是应用的分析过程和初始化过程。这样就允许在不退出解释器的情况重新加载已更改的python模块。

使用reload()函数的若干注意事项如下:

*如果模块在语法上是正确的,但在初始化过程中失败,则导入过程不能正确地将模块的名字绑定到符号表中,这时,必须在模块能被重新加载之前使用import()函数加载该模块。

*重新加载的模块不删除最初旧版本在符号表中的登记项。对于有恒定名字的对象和函数,这当然不是问题;但是,若对一模块实体更改了名字,模块名在重新加载后仍保持在符号表中

*支持扩展模块(它依赖与内置的或所支持的动态加载的函数库)的重新加载,但可能是无目标的,并且确定可能导致失败,这完全依赖于动态加载的函数库的行为

*如果以模块利用from…import…方式从另一个模块导入对象,reload()函数不重定义导入的对象,可利用import…形式避免这个问题

*提供类的重新加载模块不影响所提供类的任何已存实例——已存实例将继续使用原来的方法定义;只有该类的新实例使用新格式。这个原则对派生类同样适用

  1. repr(object)

repr()函数返回对象的字符串表示。这与将对象或属性适用单反引号(‘)的结果是一致的。返回的字符串产生一个对象,该对象的值与将

object传递给eval()函数产生的值一样,如下例所示:

>>>dict={‘One’:1,’Two:2’,’Many’:{‘Many’:4,’ManyMany’:8}}

>>>repr(dict)

“{‘One’:1,’Many’:{‘Many’:4,’ManyMany’:8},’Two’:2}”

  1. round(x[,n])

round()函数返回浮点型参数x舍入到十进制小数点后n位的值,如下例所示:

>>>round(0.4)

0.0

>>>round(0.5)

1.0

>>>round(-0.5)

-1.0

>>>round(1985,-2)

2000.0

  1. setattr(object,name,value)

该函数将object参数的name属性设置为value参数值。setattr()函数是getattr()函数的反函数,后者仅获得信息,以下语句:

setattr(myattr’,’new value’)

等价于

myobj.myattr=’new value’

setattr()函数能用在这样的情况下:属性是通过name参数以编程方式命名,而不是显式地命名属性

  1. slice([start,]stop,[,step])

该函数返回已序列切片(slice)对象,该对象表示由range(start,stop,step)指定的索引集。如果给出一个参数,此参数就作为stop参数值;如果给出两个参数,它们就作为start和stop的参数值;任何未给出参数值的参数默认取值为None。序列切片对象有3个属性(start,stop,和step),这3个属性仅仅返回要提供给slice()函数的参数

  1. str(object)

返回对象的一个字符串表示。这与repr()函数相似,唯一不同之处在于:此函数返回值设计为可打印字符串而不是与eval()函数相兼容的字符串

  1. tuple(object)

tuple()函数返回一个元组,该元组的项及项的顺序与sequence参数完全一样,以下就是tuple()函数的举例:

>>>tuple(‘abc’)

(‘a’,’b’,’c’)

>>>tuple([1,2,3])

(1,2,3)

  1. type(object)

该函数返回object参数的类型。返回值是个如类型模块所描述一样的类型对象,举例如下:

>>>import type

>>>if type(string)==type.StringType:

print ‘This is a string’

  1. unichr(i)

该函数返回代码是一个整型参数i的Unicode字符的Unicode字符串。此函数等价于前面论述的chr()函数。请注意,要将Unicode字符转换回其整数格式,可使用ord()函数;没有uniord()函数、如果给出的整数超出0~65535这个范围,则引发ValueError异常

  1. unicode(string[,encoding[,errors]]))

该函数利用编码格式解码器将给定的字符串从一种格式解码为另一种格式。编码的任何错误都用errors参数定义的字符串标记此函数特别用于在字符串和Unicode编码格式之间转换。默认(当不给出encoding参数值)操作是以严格方式将字符串解码为UTF-8格式,发生errors错误时就引发ValueError异常。有关合适的解码列表,请见codecs模块

52.vars([object])

该函数返回对应于当前局部符号表的字典。当给出模块、类或实例时,vars()函数返回对应那个对象的符号表的字典。因为结果是非定义的,所以一定不要修改返回的字典

  1. xrange([start,]stop[,step])

该函数的作用与range()函数一样,唯一的区别是:xrange()函数返回一个xrange对象。xrange()对象是个不透明对象类型,此类型返回的信息与所请求的参数列表是一致的,但是它不必存储列表中每个独立的元素。在创建非常巨大列表的情况下,此函数特别有用;利用xrange()函数节省下来的内存比起用range()函数是相当可观的

54. zip(seq1,…)

zip()函数处理一系列序列,将这些序列返回一个元组列表。其中,每个元组包含了给定的每个序列的第n个元素。以下是个例子:

>>>a=[1,2,3,4]

>>>b=[5,6,7,8]

>>>zip(a,b)

[(1,5),(2,6),(3,7),(4,8)]

  1. 执行任意语句

python支持3条指令,这3条指令允许执行一些任意文件或python代码的字符串,这3条指令是exec语句、execfile()和eval()函数。

  1. exec语句

exec语句被设计为执行能使用函数和语句的任意组合的python的任何代码片段。执行的代码访问相同的全局定义和局部定义的对象、类和方法或函数。以下是使用exec语句的简单例子:

exec “print ‘Hello World’”

也能通过提供一个包含对象及其取值的列表的字典来限定对exec语句有效的资源,如下例这样:

exec “print message” in myglobals,mylocals

能用globals()和locals()函数来获得当前的字典

请注意,exec语句执行表达式和语句、或者对表达式和语句求值,但是exec语句不返回任何值。因为exec是语句不是函数,所以任何获取返回值的试图都将导致语法错误

  1. execfile()函数

该函数执行与exec语句同样的操作,正如前面所描述的那样,它们的不同之处在于:execfile()函数从问几十年中读取被执行的语句,执行的对象不是字符串,不是代码对象;execfile()函数的其他所有方面都与exec语句等价

  1. eval()函数

该函数不允许执行任意的python语句。eval()函数被设计为:执行一个python表达式,并返回值,如下例中一样:

result=eval(userexpression)

或者在语句中更显式地给出表达式,如下例所示:

result=eval(“3+6”)

不能使用eval()函数去执行语句,根据经验,通常使用eval()函数开将一表达式求值并返回一个值,而在其他所有情况下则使用exec语句exec()

发表评论

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

网站地图xml地图