Python内置函数_集合操作类

basestring

>>> 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

>>> 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

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

>>> 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

>>> 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(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

• 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

>>> 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