转载

Python内置函数_集合操作类

basestring

basestring()

说明: basestringstrunicode 的超类 (父类) ,也是 抽象类

因此不能被调用和实例化,但可以被用来判断一个对象是否为str或者unicode的实例,

isinstance(obj, basestring)

等价于 isinstance(obj, (str, unicode))

版本: python2.3版本 以后引入该函数,兼容 python2.3 以后 python2 各版本。

注意: python3 中舍弃了该函数,所以该函数不能在 python3 中使用。

>>> isinstance("Hello world", str)
True
>>> isinstance("Hello world", basestring)
True
>>> isinstance(u"你好", unicode)
True
>>> isinstance(u"你好", basestring)
True

chr

chr(i)
返回整数i对应的ASCII字符

>>> chr(97)
'a'
>>> chr(65)
'A'

dict

dict([arg])
创建数据字典

>>> a = dict(one = 1,two = 2,three = 3)
>>> print a
{'three': 3, 'two': 2, 'one': 1}
>>> print dict(zip(['spring','summer','automn','winter'],range(4)))
{'spring': 0, 'winter': 3, 'automn': 2, 'summer': 1}

enumerate

enumerate(sequence [, start = 0])
返回一个 可枚举的对象 ,该对象的 next()方法 将返回一个 tuple

>>> t = enumerate(['spring','summer','automn','winter'],1)
>>> t.next()
(1, 'spring')
>>> t.next()
(2, 'summer')
>>> t.next()
(3, 'automn')
>>> t.next()
(4, 'winter')
>>> for i,season in enumerate(['spring','summer','automn','winter'],2):
    print i,season

    
2 spring
3 summer
4 automn
5 winter
>>> for season in enumerate(['spring','summer','automn','winter'],3):
    print season

    
(3, 'spring')
(4, 'summer')
(5, 'automn')
(6, 'winter')

format

format(value [, format_spec])

本函数把值 valueformat_spec 的格式来格式化,

然而函数解释format_spec是根据 value类型 来决定的,不同的 类型 有不同的 格式化 解释。

当参数 format_spec 为空时,本函数等同于函数 str(value) 的方式。

其实本函数调用时,是把 format(value, format_spec) 的方式转换为

type(value). format (format_spec)方式来调用,

因此在 value类型 里就查找方法__format__(),

如果找不到此方法,就会返回异常 TypeError

其中 format_spec 的编写方式如下形式:

format_spec ::= [[fill]align][sign][#][0][width][,][.precision ][type]

fill ::= <any character>

align ::= "<" | ">" | "=" | "^"

sign ::= "+" | "-" | " "

width ::= integer

precision ::= integer

type ::= "b"|"c"|"d"|"e"|"E"|"f"|"F"|"g"|"G"|"n"|"o"|"s"|"x"|"X"|"%"

fill 是表示可以填写任何字符。

align 是对齐方式,<是左对齐, >是右对齐,^是居中对齐。

sign 是符号, + 表示正号, - 表示负号。

width 是数字宽度,表示总共输出多少位数字。

precision 是小数保留位数。

type 是输出数字值是的表示方式,比如b是二进制表示;比如E是指数表示;比如X是十六进制表示。

>>> print(format(2918))
2918
>>> print(format(0x500,'X'))
500
>>> print(format(0x500,'x'))
500
>>> import math
>>> print(format(math.pi,'0=10'))
3.14159265359
>>> print(format(math.pi,'0=20'))
00000003.14159265359
>>> print(format(math.pi,'E'))
3.141593E+00
>>> print(format(math.pi,'e'))
3.141593e+00
>>> print(format(math.pi,'05.3'))
03.14
>>> print(format(math.pi,'5.3'))
 3.14
>>> print(format('test','<20'))
test                
>>> print(format('test','>20'))
                test
>>> print(format('test','^20'))
        test        
>>> print(format(math.pi,'0=+20'))
+0000003.14159265359
>>> print(format(math.pi,'0^+20'))
000+3.14159265359000

iter

iter(o[, sentinel])

如果传递了第二个参数,则 object 必须是一个可调用的对象(如,函数)。

此时, iter 创建了一个 迭代器对象 ,每次调用这个迭代器对象的__next__()方法时,都会调用object。

如果__next__的返回值等于 sentinel ,则抛出 StopIteration 异常,否则返回下一个值。

class counter:

     def __init__(self, _start, _end):
         self.start = _start
         self.end = _end
    
     def get_next(self):
         s = self.start
         if(self.start < self.end):
              self.start += 1
         else:
             raise StopIteration
    
         return s


>>>c = counter(1, 5)
>>>iterator = iter(c.get_next, 3)
>>>print(type(iterator))
<class'callable_iterator'>
>>>for i in iterator: #当self.start = 3便停止
    print(i)

1
2

list

list([iterable])
将一个集合类转换为另外一个集合类

>>> print list(range(7))
[0, 1, 2, 3, 4, 5, 6]
>>> print list('hello world')
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

max

max(iterable[, args...][key])

函数是迭代对象iterable进行比较,找出最大值返回。

当key参数不为空时,就以 key 的函数对象为判断的标准。

>>> a1 = range(10)
>>> a2 = range(0,20,3)
>>> print 'max(a1)=%d'%max(a1)
max(a1)=9
>>> print 'max(a2)=%d'%max(a2)
max(a2)=18
>>> print max(1,2)
2
>>> print max('ah','bf',key=lambda x: x[1])
ah
>>> print max(a1,a2,key = lambda x: x[1])
[0, 3, 6, 9, 12, 15, 18]
>>> def comparator(x):
    return x[2]

>>> print max('ah2','bf3',key= comparator )
bf3

min

min(iterable[, args...][key])

函数是迭代对象 iterable 进行比较,找出最小值返回。

当key参数不为空时,就以key的函数对象为判断的标准。

>>> a1 = range(10)
>>> a2 = range(0,20,3)
>>> print 'min(a1)=%d'%min(a1)
min(a1)=0
>>> print 'min(a2)=%d'%min(a2)
min(a2)=0
>>> print min(1,2)
1
>>> print min('ah','bf',key = lambda x: x[1])
bf
>>> print min(a1,a2,key = lambda x: x[1])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> def comparator(x):
    return x[2]

>>> print min('ah2','bf3',key=comparator)
ah2

range

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

产生一个序列,默认从0开始

start 为起点, stop 为终点(不包括在内), step 为步长

>>> range(1,10,2)
[1, 3, 5, 7, 9]
>>> range(10,1,-2)
[10, 8, 6, 4, 2]

set

set()
set对象实例化

>>> set('add')
set(['a', 'd'])
>>> set('python').add('hello')
>>> print set('python').add('hello')
None
>>> a = set('python')
>>> a
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> a.add('hello')
>>> a
set(['h', 'o', 'n', 'p', 't', 'y', 'hello'])
>>> a.update('python')
>>> a
set(['h', 'o', 'n', 'p', 't', 'y', 'hello'])
>>> a.update('hello')
>>> a
set(['e', 'h', 'l', 'o', 'n', 'p', 't', 'y', 'hello'])
>>> a.remove('hello')
>>> a
set(['e', 'h', 'l', 'o', 'n', 'p', 't', 'y'])
>>> b = set('hello')
>>> b
set(['h', 'e', 'l', 'o'])
>>> a - b
set(['y', 'p', 't', 'n'])
>>> a & b
set(['h', 'e', 'l', 'o'])
>>> a | b
set(['e', 'h', 'l', 'o', 'n', 'p', 't', 'y'])
>>> a != b
True
>>> a == b
False
>>> b in a
False
>>> a in b
False
>>> c = set('hell')
>>> c in b
False
>>> b
set(['h', 'e', 'l', 'o'])
>>> c
set(['h', 'e', 'l'])
>>> 'h' in c
True
>>> 'p' in c
False

frozenset

frozenset([iterable])
产生一个不可变的set

>>> a = frozenset(range(10))
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.remove(0)

Traceback (most recent call last):
  File "<pyshell#189>", line 1, in <module>
    a.remove(0)
AttributeError: 'frozenset' object has no attribute 'remove'
>>> b = set(range(10))
>>> b
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b.remove(1)
>>> b
set([0, 2, 3, 4, 5, 6, 7, 8, 9])

sorted

sorted(iterable[, cmp[, key[, reverse]]])
队集合排序

  1. 先说一下iterable,中文意思是迭代器。

Python的帮助文档中对iterable的解释是:iteralbe指的是能够一次返回它的一个成员的对象。

iterable主要包括3类:

  • 第一类是所有的序列类型,比如 list(列表)str(字符串)tuple(元组)
  • 第二类是一些非序列类型,比如 dict(字典)file(文件)
  • 第三类是你定义的任何包含__iter__()或__getitem__()方法的类的对象。
  1. Python帮助文档中对 sorted方法 的讲解:
sorted(iterable[,cmp,[,key[,reverse=True]]])
作用: Return a new sorted list from the items in iterable.

第一个参数是一个 iterable ,返回值是一个对iterable中元素进行排序后的列表(list)。

可选的参数有三个,cmp、key和reverse。

  • 1)cmp指定一个定制的比较函数,这个函数接收两个参数(iterable的元素),

    • 如果第一个参数小于第二个参数,返回一个负数;
    • 如果第一个参数等于第二个参数,返回零;
    • 如果第一个参数大于第二个参数,返回一个正数。默认值为None。
  • 2)key指定一个接收一个参数的函数,

    • 这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None。
  • 3)reverse是一个布尔值。

    • 如果设置为True,列表元素将被倒序排列。
    通常来说,key和reverse比一个等价的cmp函数处理速度要快。

    这是因为对于每个列表元素,cmp都会被调用多次,而key和reverse只被调用一次。

  1. 具体的用法如下:
  • 1)排序基础

    一个简单的升序排列很简单-只需要调用sorted()函数即可。

    这个函数返回一个新的排序列表。:

    >>> sorted([5,2,3,1,4])
    >>> [1,2,3,4,5]

    你也可以使用list的 list.sort() 方法。

    这个方法会修改原始的list(返回值为 None )。

    通常这个方法不如sorted()方便-如果你不需要原始的list, list.sort() 方法效率会稍微高一些。

    >>> a=[5,2,3,1,4]
    >>> a.sort()
    >>> a
    >>> [1,2,3,4,5]

    另一个区别在于 list.sort() 方法只为list定义。

    sorted() 函数可以接收任何的 iterable

    >>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}) 
    >>> [1, 2, 3, 4, 5]
  • 2)Key Functions(关键字函数)

    从Python2.4开始, list.sort()sorted() 方法都添加了一个 key参数 来说明一个函数,

    这个函数在做比较之前会对list中的每个元素进行调用。

    例如,这里是一个大小写不敏感的字符串比较:

    >>> sorted("This is a test string from Andrew".split(), key=str.lower) 
    >>> ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
    >>> sorted("This is a test string from Andrew".split(), key=str.upper)
    >>> ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

    key的值应该是一个函数,这个函数接收一个参数并且返回一个用于比较的关键字。

    这种技术比较快,原因在于对每个输入记录,这个函数只会被调用一次。

    对复杂对象的比较通常是使用对象的切片作为关键字。例如:

    >>> student_tuples = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10),]
    >>> sorted(student_tuples, key=lambda student: student[2]) 
    >>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    >>> 同样的技术适用于有named属性的对象。例如:
    >>> class Student:         
        def __init__(self, name, grade, age):
            self.name = name
            self.grade = grade
            self.age = age
        def __repr__(self):                 
            return repr((self.name, self.grade, self.age))  
    >>> student_objects=[Student('john','A',15),Student('jane','B',12),Student('dave','B',10),]
    >>> sorted(student_objects, key=lambda student: student.age)
    >>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
  • 3)Operator Module Functions (Operator模块中的函数)

    上面的key-function模式很常见,因此Python提供了方便的函数使得祖先函数更简单和快捷。

    operator module有itemgetter,attrgetter ,以及从Python2.6开始的methodcaller函数。

    使用这些函数,上面的例子会变得更简单和快捷:

    >>> from operator import itemgetter, attrgetter  
    >>> sorted(student_tuples, key=itemgetter(2)) 
    >>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  
    >>> sorted(student_objects, key=attrgetter('age')) 
    >>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

    operator模块支持多级排序。例如先按成绩排序,再按年龄排序:

    >>> sorted(student_tuples, key=itemgetter(1,2)) 
    >>> [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]  
    >>> sorted(student_objects, key=attrgetter('grade', 'age')) 
    >>> [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
  • 4)升序和降序

    list.sort()和sorted()都接收一个reverse参数。它是用于降序排序的标志。

    例如,为了获得学生年龄的降序排序:

    >>> sorted(student_tuples, key=itemgetter(2), reverse=True) 
    >>> [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]  
    >>> sorted(student_objects, key=attrgetter('age'), reverse=True) 
    >>> [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

    5)排序稳定性和复杂的排序 从Python2.2开始,排序都保证是稳定的。意思是当多个记录有相同的关键字时,它们原始的排序保留。

    >>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] 
    >>> sorted(data, key=itemgetter(0)) 
    >>> [('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

    注意到两个'blue'的记录保留了它们原始的顺序,

    因此('blue',1)保证在('blue',2)之前。

    这个好的特性能让你建立复杂的排序。

    例如,将学生记录按成绩降序排序、按年两升序排列。先按年龄排序,再按成绩排序。

    >>> s=sorted(student_objects,key=attrgetter('age')) 
    >>> s
    >>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    >>> sorted(s,key=attrgetter('grade'),reverse=True) 
    >>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    >>> sorted(s,key=attrgetter('grade'),reverse=False)
    >>> [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

str

str([object])
转换为string类型

In [2]: S = str('abc')

In [3]: S.
S.capitalize S.find       S.isspace    S.partition  S.rstrip     S.translate
S.center     S.format     S.istitle    S.replace    S.split      S.upper
S.count      S.index      S.isupper    S.rfind      S.splitlines S.zfill
S.decode     S.isalnum    S.join       S.rindex     S.startswith
S.encode     S.isalpha    S.ljust      S.rjust      S.strip
S.endswith   S.isdigit    S.lower      S.rpartition S.swapcase
S.expandtabs S.islower    S.lstrip     S.rsplit     S.title
字符串中字符大小写的变换:
S.lower()   #小写
S.upper()   #大写
S.swapcase()   #大小写互换
S.capitalize()   #首字母大写
S.title()    #只有首字母大写,其余为小写,模块中没有这个方法
字符串在输出时的对齐:
S.ljust(width,[fillchar])   
#输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。
S.rjust(width,[fillchar])    #右对齐
S.center(width, [fillchar])    #中间对齐
S.zfill(width)   #把S变成width长,并在右对齐,不足部分用0补足
字符串中的搜索和替换:
S.find(substr, [start, [end]])   
#返回S中出现substr的第一个字母的标号,如果S中没有substr则返回-1。
start和end作用就相当于在S[start:end]中搜索
S.index(substr, [start, [end]])   
#与find()相同,只是在S中没有substr时,会返回一个运行时错误
S.rfind(substr, [start, [end]])   
#返回S中最后出现的substr的第一个字母的标号,如果S中没有substr则返回-1,
也就是说从右边算起的第一次出现的substr的首字母标号
S.rindex(substr, [start, [end]])
S.count(substr, [start, [end]])    #计算substr在S中出现的次数
S.replace(oldstr, newstr, [count])    
#把S中的oldstar替换为newstr,count为替换次数。
这是替换的通用形式,还有一些函数进行特殊字符的替换
S.strip([chars])
#把S中前后chars中有的字符全部去掉,可以理解为把S前后chars替换为None
S.lstrip([chars])
S.rstrip([chars])
S.expandtabs([tabsize])   
#把S中的tab字符替换空格,每个tab替换为tabsize个空格,默认是8个
字符串的分割和组合:
S.split([sep, [maxsplit]]) 
#以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
S.rsplit([sep, [maxsplit]])
S.splitlines([keepends])
#把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符。
S.join(seq) #把seq代表的序列──字符串序列,用S连接起来
字符串的mapping,这一功能包含两个函数:
String.maketrans(from, to) 
#返回一个256个字符组成的翻译表,其中from中的字符被一一对应地转换成to,所以from和to必须是等长的。
S.translate(table[,deletechars]) 
#使用上面的函数产后的翻译表,把S进行翻译,并把deletechars中有的字符删掉。
需要注意的是,如果S为unicode字符串,那么就不支持deletechars参数,可以使用把某个字符翻译为None的方式实现相同的功能。
此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。
字符串还有一对编码和解码的函数:
S.encode([encoding,[errors]])
#其中encoding可以有多种值,比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。
errors默认值为"strict",意思是UnicodeError。
可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 
和所有的通过codecs.register_error注册的值。
这一部分内容涉及codecs模块,不是特明白
S.decode([encoding,[errors]])
字符串的测试函数,这一类函数在string模块中没有,这些函数返回的都是bool值:
S.startwith(prefix[,start[,end]]) 
#是否以prefix开头
S.endwith(suffix[,start[,end]]) 
#以suffix结尾
S.isalnum() 
#是否全是字母和数字,并至少有一个字符
S.isalpha() #是否全是字母,并至少有一个字符
S.isdigit() #是否全是数字,并至少有一个字符
S.isspace() #是否全是空白字符,并至少有一个字符
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否便是大写
S.istitle() #S是否是首字母大写的
字符串类型转换函数,这几个函数只在string模块中有:
string.atoi(s[,base]) 
#base默认为10,如果为0,那么s就可以是012或0x23这种形式的字符串,
如果是16那么s就只能是0x23或0X12这种形式的字符串
string.atol(s[,base]) #转成long
string.atof(s[,base]) #转成float

tuple

tuple([iterable])
生成一个tuple类型

>>> print tuple([1,2,3])
(1, 2, 3)
>>> print tuple((1,2,3))
(1, 2, 3)
>>> print tuple('hello')
('h', 'e', 'l', 'l', 'o')

unichr

unichr(i)
返回给定int类型的unicode

>>> unichr(97)
u'a'
>>> unichr(65)
u'A'

xrange

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

xrange()函数range() 类似,但 xrnage() 并不创建列表,

而是返回一个xrange对象,它的行为与列表相似,

但是只在需要时才计算列表值,当列表很大时,这个特性能为我们节省内存

>>> x=xrange(0,8)
>>> print x
xrange(8)
>>> print x[0]
0
>>> print x[7]
7
>>> print x[8]
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: xrange object index out of range
>>> x=range(0,8)
>>> print x
[0, 1, 2, 3, 4, 5, 6, 7]
>>> print x[0]
0
>>> print x[8]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
range([start,] stop [,step])->list of integers
原文  http://www.cnblogs.com/oneTOinf/p/7215879.html
正文到此结束
Loading...