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()方法将返回一个tuple1 >>> 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])
产生一个不可变的set1 >>> 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类型的unicode1 >>> 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
时间： 2024-10-24 10:22:22