01Python内置函数_集合操作类

Posted 2020-09-27

basestring

basestring()
说明：basestring是str和unicode的超类（父类），也是抽象类，
因此不能被调用和实例化，但可以被用来判断一个对象是否为str或者unicode的实例，
isinstance(obj, basestring)
等价于isinstance(obj, (str, unicode))；
版本：python2.3版本以后引入该函数，兼容python2.3以后python2各版本。
注意：python3中舍弃了该函数，所以该函数不能在python3中使用。

1 >>> isinstance("Hello world", str)
2 True
3 >>> isinstance("Hello world", basestring)
4 True
5 >>> isinstance(u"你好", unicode)
6 True
7 >>> isinstance(u"你好", basestring)
8 True

chr

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

1 >>> chr(97)
2 ‘a‘
3 >>> chr(65)
4 ‘A‘

dict

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

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

enumerate

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

 1 >>> t = enumerate([‘spring‘,‘summer‘,‘automn‘,‘winter‘],1)
 2 >>> t.next()
 3 (1, ‘spring‘)
 4 >>> t.next()
 5 (2, ‘summer‘)
 6 >>> t.next()
 7 (3, ‘automn‘)
 8 >>> t.next()
 9 (4, ‘winter‘)
10 >>> for i,season in enumerate([‘spring‘,‘summer‘,‘automn‘,‘winter‘],2):
11         print i,season
12
13 
14 2 spring
15 3 summer
16 4 automn
17 5 winter
18 >>> for season in enumerate([‘spring‘,‘summer‘,‘automn‘,‘winter‘],3):
19         print season
20 
21 (3, ‘spring‘)
22 (4, ‘summer‘)
23 (5, ‘automn‘)
24 (6, ‘winter‘)

format

format(value [, format_spec])
本函数把值value按format_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是十六进制表示。

 1 >>> print(format(2918))
 2 2918
 3 >>> print(format(0x500,‘X‘))
 4 500
 5 >>> print(format(0x500,‘x‘))
 6 500
 7 >>> import math
 8 >>> print(format(math.pi,‘0=10‘))
 9 3.14159265359
10 >>> print(format(math.pi,‘0=20‘))
11 00000003.14159265359
12 >>> print(format(math.pi,‘E‘))
13 3.141593E+00
14 >>> print(format(math.pi,‘e‘))
15 3.141593e+00
16 >>> print(format(math.pi,‘05.3‘))
17 03.14
18 >>> print(format(math.pi,‘5.3‘))
19  3.14
20 >>> print(format(‘test‘,‘<20‘))
21 test                
22 >>> print(format(‘test‘,‘>20‘))
23                 test
24 >>> print(format(‘test‘,‘^20‘))
25         test        
26 >>> print(format(math.pi,‘0=+20‘))
27 +0000003.14159265359
28 >>> print(format(math.pi,‘0^+20‘))
29 000+3.14159265359000

iter

iter(o[, sentinel])
如果传递了第二个参数，则object必须是一个可调用的对象（如，函数）。
此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object。
如果__next__的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值。

 1 class counter:
 2 
 3      def __init__(self, _start, _end):
 4          self.start = _start
 5          self.end = _end
 6 
 7      def get_next(self):
 8          s = self.start
 9          if(self.start < self.end):
10               self.start += 1
11          else:
12              raise StopIteration
13 
14          return s

1 >>>c = counter(1, 5)
2 >>>iterator = iter(c.get_next, 3)
3 >>>print(type(iterator))
4 <class ‘callable_iterator‘>
5 >>>for i in iterator: #当self.start = 3便停止
6     print(i)
7 
8 1
9 2

list

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

1 >>> print list(range(7))
2 [0, 1, 2, 3, 4, 5, 6]
3 >>> print list(‘hello world‘)
4 [‘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的函数对象为判断的标准。

 1 >>> a1 = range(10)
 2 >>> a2 = range(0,20,3)
 3 >>> print ‘min(a1)=%d‘%min(a1)
 4 min(a1)=0
 5 >>> print ‘min(a2)=%d‘%min(a2)
 6 min(a2)=0
 7 >>> print min(1,2)
 8 1
 9 >>> print min(‘ah‘,‘bf‘,key = lambda x: x[1])
10 bf
11 >>> print min(a1,a2,key = lambda x: x[1])
12 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
13 >>> def comparator(x):
14     return x[2]
15 
16 >>> print min(‘ah2‘,‘bf3‘,key=comparator)
17 ah2 

range

range([start], stop[, step])
产生一个序列，默认从0开始
start为起点，stop为终点（不包括在内）,step为步长

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

set

set()
set对象实例化

 1 >>> set(‘add‘)
 2 set([‘a‘, ‘d‘])
 3 >>> set(‘python‘).add(‘hello‘)
 4 >>> print set(‘python‘).add(‘hello‘)
 5 None
 6 >>> a = set(‘python‘)
 7 >>> a
 8 set([‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘])
 9 >>> a.add(‘hello‘)
10 >>> a
11 set([‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘, ‘hello‘])
12 >>> a.update(‘python‘)
13 >>> a
14 set([‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘, ‘hello‘])
15 >>> a.update(‘hello‘)
16 >>> a
17 set([‘e‘, ‘h‘, ‘l‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘, ‘hello‘])
18 >>> a.remove(‘hello‘)
19 >>> a
20 set([‘e‘, ‘h‘, ‘l‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘])
21 >>> b = set(‘hello‘)
22 >>> b
23 set([‘h‘, ‘e‘, ‘l‘, ‘o‘])
24 >>> a - b
25 set([‘y‘, ‘p‘, ‘t‘, ‘n‘])
26 >>> a & b
27 set([‘h‘, ‘e‘, ‘l‘, ‘o‘])
28 >>> a | b
29 set([‘e‘, ‘h‘, ‘l‘, ‘o‘, ‘n‘, ‘p‘, ‘t‘, ‘y‘])
30 >>> a != b
31 True
32 >>> a == b
33 False
34 >>> b in a
35 False
36 >>> a in b
37 False
38 >>> c = set(‘hell‘)
39 >>> c in b
40 False
41 >>> b
42 set([‘h‘, ‘e‘, ‘l‘, ‘o‘])
43 >>> c
44 set([‘h‘, ‘e‘, ‘l‘])
45 >>> ‘h‘ in c
46 True
47 >>> ‘p‘ in c
48 False

frozenset

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

 1 >>> a = frozenset(range(10))
 2 >>> a
 3 frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 4 >>> a.remove(0)
 5 
 6 Traceback (most recent call last):
 7   File "<pyshell#189>", line 1, in <module>
 8     a.remove(0)
 9 AttributeError: ‘frozenset‘ object has no attribute ‘remove‘
10 >>> b = set(range(10))
11 >>> b
12 set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
13 >>> b.remove(1)
14 >>> b
15 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__()方法的类的对象。

2.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只被调用一次。

3.具体的用法如下：
1)排序基础
一个简单的升序排列很简单-只需要调用sorted()函数即可。 
这个函数返回一个新的排序列表。：

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

你也可以使用list的list.sort()方法。
这个方法会修改原始的list（返回值为None）。
通常这个方法不如sorted()方便-如果你不需要原始的list，list.sort()方法效率会稍微高一些。

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

另一个区别在于list.sort()方法只为list定义。
而sorted()函数可以接收任何的iterable。

1 >>> sorted({1: ‘D‘, 2: ‘B‘, 3: ‘B‘, 4: ‘E‘, 5: ‘A‘}) 
2 [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的值应该是一个函数，这个函数接收一个参数并且返回一个用于比较的关键字。
这种技术比较快，原因在于对每个输入记录，这个函数只会被调用一次。
对复杂对象的比较通常是使用对象的切片作为关键字。例如：

1 >>> student_tuples = [(‘john‘, ‘A‘, 15),(‘jane‘, ‘B‘, 12),(‘dave‘, ‘B‘, 10),]
2 >>> sorted(student_tuples, key=lambda student: student[2]) 
3 [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

同样的技术适用于有named属性的对象。例如：

 1 >>> class Student:         
 2         def __init__(self, name, grade, age):
 3             self.name = name
 4             self.grade = grade
 5             self.age = age
 6         def __repr__(self):                 
 7             return repr((self.name, self.grade, self.age))  
 8 >>> student_objects=[Student(‘john‘,‘A‘,15),Student(‘jane‘,‘B‘,12),Student(‘dave‘,‘B‘,10),]
 9 >>> sorted(student_objects, key=lambda student: student.age)
10 [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]

3)Operator Module Functions (Operator模块中的函数)
上面的key-function模式很常见，因此Python提供了方便的函数使得祖先函数更简单和快捷。
operator module有itemgetter,attrgetter，以及从Python2.6开始的methodcaller函数。
使用这些函数，上面的例子会变得更简单和快捷：

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

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

1 >>> sorted(student_tuples, key=itemgetter(1,2)) 
2 [(‘john‘, ‘A‘, 15), (‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12)]  
3 >>> sorted(student_objects, key=attrgetter(‘grade‘, ‘age‘)) 
4 [(‘john‘, ‘A‘, 15), (‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12)]

4)升序和降序
list.sort()和sorted()都接收一个reverse参数。它是用于降序排序的标志。
例如，为了获得学生年龄的降序排序：

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

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

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

注意到两个‘blue‘的记录保留了它们原始的顺序，
因此(‘blue‘,1)保证在(‘blue‘,2)之前。  
这个好的特性能让你建立复杂的排序。
例如，将学生记录按成绩降序排序、按年两升序排列。先按年龄排序，再按成绩排序。

1 >>> s=sorted(student_objects,key=attrgetter(‘age‘)) 
2 >>> s
3 [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
4 >>> sorted(s,key=attrgetter(‘grade‘),reverse=True) 
5 [(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
6 >>> sorted(s,key=attrgetter(‘grade‘),reverse=False)
7 [(‘john‘, ‘A‘, 15), (‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12)] 

str

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

 1 In [2]: S = str(‘abc‘)
 2 
 3 In [3]: S.
 4 S.capitalize S.find       S.isspace    S.partition  S.rstrip     S.translate
 5 S.center     S.format     S.istitle    S.replace    S.split      S.upper
 6 S.count      S.index      S.isupper    S.rfind      S.splitlines S.zfill
 7 S.decode     S.isalnum    S.join       S.rindex     S.startswith
 8 S.encode     S.isalpha    S.ljust      S.rjust      S.strip
 9 S.endswith   S.isdigit    S.lower      S.rpartition S.swapcase
10 S.expandtabs S.islower    S.lstrip     S.rsplit     S.title 

字符串中字符大小写的变换：

1 S.lower()   #小写
2 S.upper()   #大写
3 S.swapcase()   #大小写互换
4 S.capitalize()   #首字母大写
5 S.title()    #只有首字母大写，其余为小写，模块中没有这个方法 

字符串在输出时的对齐：

1 S.ljust(width,[fillchar])   
2 #输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
3 S.rjust(width,[fillchar])    #右对齐
4 S.center(width, [fillchar])    #中间对齐
5 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的首字母标号

1 S.rindex(substr, [start, [end]])
2 S.count(substr, [start, [end]])    #计算substr在S中出现的次数
3 S.replace(oldstr, newstr, [count])    
4 #把S中的oldstar替换为newstr，count为替换次数。

这是替换的通用形式，还有一些函数进行特殊字符的替换

1 S.strip([chars])
2 #把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None
3 S.lstrip([chars])
4 S.rstrip([chars])
5 S.expandtabs([tabsize])   
6 #把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，这一功能包含两个函数：

1 String.maketrans(from, to) 
2 #返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。
3 S.translate(table[,deletechars]) 
4 #使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。

需要注意的是，如果S为unicode字符串，那么就不支持deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。
此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。

字符串还有一对编码和解码的函数：

1 S.encode([encoding,[errors]])
2 #其中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模块中有：

1 string.atoi(s[,base]) 
2 #base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，
3 如果是16那么s就只能是0x23或0X12这种形式的字符串
4 string.atol(s[,base]) #转成long
5 string.atof(s[,base]) #转成float 

tuple

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

1 >>> print tuple([1,2,3])
2 (1, 2, 3)
3 >>> print tuple((1,2,3))
4 (1, 2, 3)
5 >>> print tuple(‘hello‘)
6 (‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘) 

unichr

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

1 >>> unichr(97)
2 u‘a‘
3 >>> unichr(65)
4 u‘A‘ 

xrange

xrange([start], stop[, step])
xrange()函数与range()类似，但xrnage()并不创建列表，
而是返回一个xrange对象，它的行为与列表相似，
但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存

 1 >>> x=xrange(0,8)
 2 >>> print x
 3 xrange(8)
 4 >>> print x[0]
 5 0
 6 >>> print x[7]
 7 7
 8 >>> print x[8]
 9 Traceback (most recent call last):
10  File "<stdin>", line 1, in <module>
11 IndexError: xrange object index out of range
12 >>> x=range(0,8)
13 >>> print x
14 [0, 1, 2, 3, 4, 5, 6, 7]
15 >>> print x[0]
16 0
17 >>> print x[8]
18 Traceback (most recent call last):
19   File "<stdin>", line 1, in <module>
20 IndexError: list index out of range
21 range([start,] stop [,step])->list of integers