python的元组、列表、字典数据类型是很python(there python is a adjective)的数据结构。这些结构都是经过足够优化后的,所以如果使用好的话,在某些area会有很大的益处。
元组
个人认为就像java的数组,python中的元组有以下特性:
- 任意对象的有序集合,这条没啥说的,数组的同性;
- 通过偏移读取;
- 一旦生成,不可改变;
- 固定长度,支持嵌套
来例子吧:
上面的例子足以说明大部分了,使用元组时最重要的一点是“一旦生成,就不可变了”。
列表
列表就像java里的collection,所具有的特性也要比元组更多,更灵活,其character总结如下:
- 任意对象的有序集合;
- 可通过偏移存取,注意,列表中的元素都是可变的,这是不同于元组的;
- 长度可变,支持嵌套;
- 还有一些类似java的对象引用机制
由于列表的这些特性,使得列表在实际应用中被广泛使用,下面是一些例子。
1) 首先是基本用法
2) 索引和分片,赋值(单个元素赋值,分片赋值)
3) 添加、排序、删除操作
4)一些有趣的用法(来自论坛 id—咖啡舞者)
去掉列表中每个元素头尾的空格:
把列表中,大于3的元素,乘以2:
把列表1的每一个元素和列表2的每一个元素相乘:
- >>> lst1 = [2, 4, 6]
- >>> lst2 = [4, 3, -9]
- >>> [x*y for x in lst1 for y in lst2]
- [8, 6, -18, 16, 12, -36, 24, 18, -54]
取获[0-10)的平方:
字典
python里的字典就像java里的HashMap,以键值对的方式存在并操作,其特点如下
- 通过键来存取,而非偏移量;
- 键值对是无序的;
- 键和值可以是任意对象;
- 长度可变,任意嵌套;
- 在字典里,不能再有序列操作,虽然字典在某些方面与列表类似,但不要把列表套在字典上
1) 基本操作
2) 修改,删除,添加
在这里需要来一句,对于字典的扩充,只需定义一个新的键值对即可,而对于列表,就只能用append方法或分片赋值。
3)对字典的遍历
文件
与java的File类相比,python的文件类要狭义一些
1) 文件写
python的一个open语句就打开了一个文件(当给定的文件不存在时,会自动建立一个新的文件)。open的第一个参数是文件名,第二个参数是操作模式,所谓操作模式就是你打开一个文件是用来干什么的,是读,还是写(当然操作模式不仅只有读和写)。还有一件事,操作完要记得关。当open('myfile', 'w') 后面的模式为'w'时候,如果文件不存在,会在'myfile'的路径下自动创建文件。
2) 文件读
很是简单,这样两句就顶java一长串的流嵌套,当然,java那样做也是有道理的。
ok,学了不少,说实话,python的core真的没多少,也很简单,难的是何时和如何用python。
python 字符串列表字典元组等操作
- 创建列表
- sample_list = ['a',1,('a','b')]
- Python 列表操作
- sample_list = ['a','b',0,1,3]
- 得到列表中的某一个值
- value_start = sample_list[0]
- end_value = sample_list[-1]
- 删除列表的第一个值
- del sample_list[0]
- 在列表中插入一个值
- sample_list[0:0] = ['sample value']
- 得到列表的长度
- list_length = len(sample_list)
- 列表遍历
- for element in sample_list:
- print 'element'
- Python 列表高级操作/技巧
- 产生一个数值递增列表
- num_inc_list = range(30)
- #will return a list [0,1,2,...,29]
- 用某个固定值初始化列表
- initial_value = 0
- list_length = 5
- sample_list = [ initial_value for i in range(10)]
- sample_list = [initial_value]*list_length
- # sample_list ==[0,0,0,0,0]
- 附:python内置类型
- 1、list:列表(即动态数组,C++标准库的vector,但可含不同类型的元素于一个list中)
- a = ["I","you","he","she"] #元素可为任何类型。
- 下标:按下标读写,就当作数组处理
- 以0开始,有负下标的使用
- 0第一个元素,-1最后一个元素,
- -len第一个元素,len-1最后一个元素
- 取list的元素数量
- len(list) #list的长度。实际该方法是调用了此对象的__len__(self)方法。
- 创建连续的list
- L = range(1,5) #即 L=[1,2,3,4],不含最后一个元素
- L = range(1, 10, 2) #即 L=[1, 3, 5, 7, 9]
- list的方法
- L.append(var) #追加元素
- L.insert(index,var)
- L.pop(var) #返回最后一个元素,并从list中删除之
- L.remove(var) #删除第一次出现的该元素
- L.count(var) #该元素在列表中出现的个数
- L.index(var) #该元素的位置,无则抛异常
- L.extend(list) #追加list,即合并list到L上
- L.sort() #排序
- L.reverse() #倒序
- list 操作符:,+,*,关键字del
- a[1:] #片段操作符,用于子list的提取
- [1,2]+[3,4] #为[1,2,3,4]。同extend()
- [2]*4 #为[2,2,2,2]
- del L[1] #删除指定下标的元素
- del L[1:3] #删除指定下标范围的元素
- list的复制
- L1 = L #L1为L的别名,用C来说就是指针地址相同,对L1操作即对L操作。函数参数就是这样传递的
- L1 = L[:] #L1为L的克隆,即另一个拷贝。
- list comprehension
- [ <expr1> for k in L if <expr2> ]
- 2、dictionary: 字典(即C++标准库的map)
- dict = {'ob1':'computer', 'ob2':'mouse', 'ob3':'printer'}
- 每一个元素是pair,包含key、value两部分。key是Integer或string类型,value 是任意类型。
- 键是唯一的,字典只认最后一个赋的键值。
- dictionary的方法
- D.get(key, 0) #同dict[key],多了个没有则返回缺省值,0。[]没有则抛异常
- D.has_key(key) #有该键返回TRUE,否则FALSE
- D.keys() #返回字典键的列表
- D.values() #以列表的形式返回字典中的值,返回值的列表中可包含重复元素
- D.items() #将所有的字典项以列表方式返回,这些列表中的每一项都来自于(键,值),但是项在返回时并没有特殊的顺序
- D.update(dict2) #增加合并字典
- D.popitem() #得到一个pair,并从字典中删除它。已空则抛异常
- D.clear() #清空字典,同del dict
- D.copy() #拷贝字典
- D.cmp(dict1,dict2) #比较字典,(优先级为元素个数、键大小、键值大小)
- #第一个大返回1,小返回-1,一样返回0
- dictionary的复制
- dict1 = dict #别名
- dict2=dict.copy() #克隆,即另一个拷贝。
- 3、tuple:元组(即常量数组)
- tuple = ('a', 'b', 'c', 'd', 'e')
- 可以用list的 [],:操作符提取元素。就是不能直接修改元素。
- 4、string: 字符串(即不能修改的字符list)
- str = "Hello My friend"
- 字符串是一个整体。如果你想直接修改字符串的某一部分,是不可能的。但我们能够读出字符串的某一部分。
- 子字符串的提取
- str[:6]
- 字符串包含判断操作符:in,not in
- "He" in str
- "she" not in str
- string模块,还提供了很多方法,如
- S.find(substring, [start [,end]]) #可指范围查找子串,返回索引值,否则返回-1
- S.rfind(substring,[start [,end]]) #反向查找
- S.index(substring,[start [,end]]) #同find,只是找不到产生ValueError异常
- S.rindex(substring,[start [,end]])#同上反向查找
- S.count(substring,[start [,end]]) #返回找到子串的个数
- S.lowercase()
- S.capitalize() #首字母大写
- S.lower() #转小写
- S.upper() #转大写
- S.swapcase() #大小写互换
- S.split(str, ' ') #将string转list,以空格切分
- S.join(list, ' ') #将list转string,以空格连接
- 处理字符串的内置函数
- len(str) #串长度
- cmp("my friend", str) #字符串比较。第一个大,返回1
- max('abcxyz') #寻找字符串中最大的字符
- min('abcxyz') #寻找字符串中最小的字符
- string的转换
- float(str) #变成浮点数,float("1e-1") 结果为0.1
- int(str) #变成整型, int("12") 结果为12
- int(str,base) #变成base进制整型数,int("11",2) 结果为2
- long(str) #变成长整型,
- long(str,base) #变成base进制长整型,
- 字符串的格式化(注意其转义字符,大多如C语言的,略)
- str_format % (参数列表) #参数列表是以tuple的形式定义的,即不可运行中改变
- >>>print ""%s's height is %dcm" % ("My brother", 180)
- #结果显示为 My brother's height is 180cm
- 。。。。。。。。。。。。。。。。。。
- list 和 tuple 的相互转化
- tuple(ls)
- list(ls)
python 字符串元组列表字典字符串的转化
#-*-coding:utf-8-*-
#1、字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type 'str'> {'age': 7, 'name': 'Zara', 'class': 'First'} print type(str(dict)), str(dict) #字典可以转为元组,返回:('age', 'name', 'class') print tuple(dict) #字典可以转为元组,返回:(7, 'Zara', 'First') print tuple(dict.values()) #字典转为列表,返回:['age', 'name', 'class'] print list(dict) #字典转为列表 print dict.values #2、元组 tup=(1, 2, 3, 4, 5) #元组转为字符串,返回:(1, 2, 3, 4, 5) print tup.__str__() #元组转为列表,返回:[1, 2, 3, 4, 5] print list(tup) #元组不可以转为字典 #3、列表 nums=[1, 3, 5, 7, 8, 13, 20]; #列表转为字符串,返回:[1, 3, 5, 7, 8, 13, 20] print str(nums) #列表转为元组,返回:(1, 3, 5, 7, 8, 13, 20) print tuple(nums) #列表不可以转为字典 #4、字符串 #字符串转为元组,返回:(1, 2, 3) print tuple(eval("(1,2,3)")) #字符串转为列表,返回:[1, 2, 3] print list(eval("(1,2,3)")) #字符串转为字典,返回:<type 'dict'> print type(eval("{'name':'ljq', 'age':24}"))
python 字符串
1、去空格及特殊符号
代码如下:s.strip().lstrip().rstrip(',')2、复制字符串代码如下:#strcpy(sStr1,sStr2) sStr1 = 'strcpy' sStr2 = sStr1 sStr1 = 'strcpy2' print sStr23、连接字符串代码如下:#strcat(sStr1,sStr2) sStr1 = 'strcat' sStr2 = 'append' sStr1 += sStr2 print sStr14、查找字符代码如下:#strchr(sStr1,sStr2) # < 0 为未找到 sStr1 = 'strchr' sStr2 = 's' nPos = sStr1.index(sStr2) print nPos5、比较字符串代码如下:#strcmp(sStr1,sStr2) sStr1 = 'strchr' sStr2 = 'strch' print cmp(sStr1,sStr2)6、扫描字符串是否包含指定的字符代码如下:#strspn(sStr1,sStr2) sStr1 = '12345678' sStr2 = '456' #sStr1 and chars both in sStr1 and sStr2 print len(sStr1 and sStr2)7、字符串长度代码如下:#strlen(sStr1) sStr1 = 'strlen' print len(sStr1)8、将字符串中的大小写转换代码如下:S.lower() #小写 S.upper() #大写 S.swapcase() #大小写互换 S.capitalize() #首字母大写 String.capwords(S) #这是模块中的方法。它把S用split()函数分开,然后用capitalize()把首字母变成大写,最后用join()合并到一起 #实例: #strlwr(sStr1) sStr1 = 'JCstrlwr' sStr1 = sStr1.upper() #sStr1 = sStr1.lower() print sStr19、追加指定长度的字符串代码如下:#strncat(sStr1,sStr2,n) sStr1 = '12345' sStr2 = 'abcdef' n = 3 sStr1 += sStr2[0:n] print sStr110、字符串指定长度比较代码如下:#strncmp(sStr1,sStr2,n) sStr1 = '12345' sStr2 = '123bc' n = 3 print cmp(sStr1[0:n],sStr2[0:n])11、复制指定长度的字符代码如下:#strncpy(sStr1,sStr2,n) sStr1 = '' sStr2 = '12345' n = 3 sStr1 = sStr2[0:n] print sStr112、将字符串前n个字符替换为指定的字符代码如下:#strnset(sStr1,ch,n) sStr1 = '12345' ch = 'r' n = 3 sStr1 = n * ch + sStr1[3:] print sStr113、扫描字符串代码如下:#strpbrk(sStr1,sStr2) sStr1 = 'cekjgdklab' sStr2 = 'gka' nPos = -1 for c in sStr1: if c in sStr2: nPos = sStr1.index(c) break print nPos14、翻转字符串代码如下:#strrev(sStr1) sStr1 = 'abcdefg' sStr1 = sStr1[::-1] print sStr115、查找字符串代码如下:#strstr(sStr1,sStr2) sStr1 = 'abcdefg' sStr2 = 'cde' print sStr1.find(sStr2)16、分割字符串代码如下:#strtok(sStr1,sStr2) sStr1 = 'ab,cde,fgh,ijk' sStr2 = ',' sStr1 = sStr1[sStr1.find(sStr2) + 1:] print sStr1 #或者 s = 'ab,cde,fgh,ijk' print(s.split(','))17、连接字符串代码如下:delimiter = ',' mylist = ['Brazil', 'Russia', 'India', 'China'] print delimiter.join(mylist)18、PHP 中 addslashes 的实现代码如下:def addslashes(s): d = {'"':'\\"', "'":"\\'", "\0":"\\\0", "\\":"\\\\"} return ''.join(d.get(c, c) for c in s) s = "John 'Johny' Doe (a.k.a. \"Super Joe\")\\\0" print s print addslashes(s)19、只显示字母与数字代码如下:def OnlyCharNum(s,oth=''): s2 = s.lower(); fomart = 'abcdefghijklmnopqrstuvwxyz0123456789' for c in s2: if not c in fomart: s = s.replace(c,''); return s; print(OnlyStr("a000 aa-b"))20、截取字符串代码如下:str = '0123456789′ print str[0:3] #截取第一位到第三位的字符 print str[:] #截取字符串的全部字符 print str[6:] #截取第七个字符到结尾 print str[:-3] #截取从头开始到倒数第三个字符之前 print str[2] #截取第三个字符 print str[-1] #截取倒数第一个字符 print str[::-1] #创造一个与原字符串顺序相反的字符串 print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符 print str[-3:] #截取倒数第三位到结尾 print str[:-5:-3] #逆序截取,具体啥意思没搞明白?21、字符串在输出时的对齐代码如下:S.ljust(width,[fillchar]) #输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。 S.rjust(width,[fillchar]) #右对齐 S.center(width, [fillchar]) #中间对齐 S.zfill(width) #把S变成width长,并在右对齐,不足部分用0补足22、字符串中的搜索和替换代码如下: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个23、字符串的分割和组合代码如下:S.split([sep, [maxsplit]]) #以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 S.rsplit([sep, [maxsplit]]) S.splitlines([keepends]) #把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符。 S.join(seq) #把seq代表的序列──字符串序列,用S连接起来24、字符串的mapping,这一功能包含两个函数代码如下:String.maketrans(from, to) #返回一个256个字符组成的翻译表,其中from中的字符被一一对应地转换成to,所以from和to必须是等长的。 S.translate(table[,deletechars]) # 使用上面的函数产后的翻译表,把S进行翻译,并把deletechars中有的字符删掉。需要注意的是,如果S为unicode字符串,那么就不支持 deletechars参数,可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。25、字符串还有一对编码和解码的函数代码如下: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]])26、字符串的测试、判断函数,这一类函数在string模块中没有,这些函数返回的都是bool值代码如下:S.startswith(prefix[,start[,end]]) #是否以prefix开头 S.endswith(suffix[,start[,end]]) #以suffix结尾 S.isalnum() #是否全是字母和数字,并至少有一个字符 S.isalpha() #是否全是字母,并至少有一个字符 S.isdigit() #是否全是数字,并至少有一个字符 S.isspace() #是否全是空白字符,并至少有一个字符 S.islower() #S中的字母是否全是小写 S.isupper() #S中的字母是否便是大写 S.istitle() #S是否是首字母大写的27、字符串类型转换函数,这几个函数只在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这里再强调一次,字符串对象是不可改变的,也就是说在python创建一个字符串后,你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后,都会返回一个新的字符串,原字串并没有变。其实这也是有变通的办法的,可以用S=list(S)这个函数把S变为由单个字符为成员的list,这样的话就可以使用S[3]='a'的方式改变值,然后再使用S=" ".join(S)还原成字符串
介绍字符串相关的:比较,截取,替换,长度,连接,反转,编码,格式化,查找,复制,大小写,分割等操作
什么是字符串
python 字符串相关特性
字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。 通常以串的整体作为操作对象,如:在串中查找某个子串、求取一个子串、在串的某个位置上插入一个子串以及删除一个子串等。两个字符串相等的充要条件是:长度相等,并且各个对应位置上的字符都相等。
1 属于python基本数据类型和结构的一种。2 本身是不可变的数据类型。 3 有很多内置的方法
字符串连接
方法1: 用字符串的join方法
a = [ 'a' , 'b' , 'c' , 'd' ]
content = ''
content = '' . join( a)
print content
方法2: 用字符串的替换占位符替换
a = [ 'a' , 'b' , 'c' , 'd' ]
content = ''
content = ' %s%s%s%s ' % tuple( a)
print content
字符串截取
我们可以通过索引来提取想要获取的字符,可以把python的字符串也做为字符串的列表就更好理解
python的字串列表有2种取值顺序
1是从左到右索引默认0开始的,最大范围是字符串长度少1
s = 'ilovepython'
s[0]的结果是i
2是从右到左索引默认-1开始的,最大范围是字符串开头
s = 'ilovepython'
s[-1]的结果是n
上面这个是取得一个字符,如果你的实际要取得一段子串的话,可以用到变量[头下标:尾下标],就可以截取相应的字符串,其中下标是从0开始算起,可以是正数或负数,下标可以为空表示取到头或尾。
比如
s = 'ilovepython'
s[1:5]的结果是love
当使用以冒号分隔的字符串,python返回一个新的对象,结果包含了以这对偏移标识的连续的内容,左边的开始是包含了下边界,比如
上面的结果包含了s[1]的值l,而取到的最大范围不包括上边界,就是s[5]的值p字符串替换
字符串替换可以用内置的方法和正则表达式完成。
1用字符串本身的replace方法:a = 'hello word'
b = a . replace( 'word' , 'python')
print b
2用正则表达式来完成替换:
import re
a = 'hello word'
strinfo = re . compile( 'word')
b = strinfo . sub( 'python' , a)
print b
字符串比较
cmp方法比较两个对象,并根据结果返回一个整数。cmp(x,y)如果X< Y,返回值是负数 如果X>Y 返回的值为正数。
sStr1 = 'strch'
sStr2 = 'strchr'
print cmp( sStr1 , sStr2) ##-1
字符串相加
我们通过操作符号+来进行字符串的相加,不过建议还是用其他的方式来进行字符串的拼接,这样效率高点。
原因:在循环连接字符串的时候,他每次连接一次,就要重新开辟空间,然后把字符串连接起来,再放入新的空间,再一次循环,又要开辟新的空间,把字符串连接起来放入新的空间,如此反复,内存操作比较频繁,每次都要计算内存空间,然后开辟内存空间,再释放内存空间,效率非常低。
sStr1 = 'strch'
sStr2 = 'strchr'
newstr = sStr1 + sStr2
print newstr
字符串查找
python 字符串查找有4个方法,1 find,2 index方法,3 rfind方法,4 rindex方法。
1 find()方法:
info = 'abca'
print info . find( 'a') ##从下标0开始,查找在字符串里第一个出现的子串,返回结果:0
info = 'abca'
print info . find( 'a' , 1) ##从下标1开始,查找在字符串里第一个出现的子串:返回结果3
info = 'abca'
print info . find( '333') ##返回-1,查找不到返回-1
2 index()方法:
python 的index方法是在字符串里查找子串第一次出现的位置,类似字符串的find方法,不过比find方法更好的是,如果查找不到子串,会抛出异常,而不是返回-1
info = 'abca'
print info . index( 'a')
print info . index( '33')
字符串分割
字符串分割,可以用split,rsplit方法,通过相应的规则来切割成生成列表对象
info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'
content = info . split( '$')
print content
字符串翻转
通过步进反转[::-1]
a = 'abcd'
b = a [:: - 1 ] ##[::-1]通过步进反转
print b
字符串编码
通过字符串的decode和encode方法
1 encode([encoding,[errors]])
#其中encoding可以有多种值,比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict",意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。S.decode([encoding,[errors]]) 下面是字符串编码应用:
a = '你好'
b = 'python'
print a . decode( 'utf-8') . encode( 'gbk') ##decode方法把字符串转换为unicode对象,然后通过encode方法转换为指定的编码字符串对象
print b . decode( 'utf-8') ##decode方法把字符串转换为unicode对象
字符串追加和拼接
通过字符串的占位符来进行字符串的拼接
#1 元组拼接
m = 'python'
astr = 'i love %s ' % m
print astr
#2 字符串的format方法
m = 'python'
astr = "i love {python}" . format( python = m)
print astr
#3 字典格式化字符串
m = 'python'
astr = "i love %(python)s " % { 'python' : m }
print astr
字符串复制
通过变量来进行赋值
fstr = 'strcpy'
sstr = fstr
fstr = 'strcpy2'
print sstr
字符串长度
通过内置方法len()来计算字符串的长度,注意这个计算的是字符的长度。
aa = 'afebb'
bb = '你'
print len( aa)
print len(bb)
字符串大小写
通过下面的upper(),lower()等方法来转换大小写
S.upper()#S中的字母大写
S.lower() #S中的字母小写
S.capitalize() #首字母大写
S.istitle() #S是否是首字母大写的
S.isupper() #S中的字母是否便是大写
S.islower() #S中的字母是否全是小写字符串去空格
通过strip(),lstrip(),rstrip()方法去除字符串的空格
S.strip()去掉字符串的左右空格
S.lstrip()去掉字符串的左边空格
S.rstrip()去掉字符串的右边空格字符串其他方法
字符串相关的其他方法:count(),join()方法等。
S.center(width, [fillchar]) #中间对齐
S.count(substr, [start, [end]]) #计算substr在S中出现的次数
S.expandtabs([tabsize]) #把S中的tab字符替换没空格,每个tab替换为tabsize个空格,默认是8个
S.isalnum() #是否全是字母和数字,并至少有一个字符
S.isalpha() #是否全是字母,并至少有一个字符
S.isspace() #是否全是空白字符,并至少有一个字符
S.join()#S中的join,把列表生成一个字符串对象
S.ljust(width,[fillchar]) #输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。
S.rjust(width,[fillchar]) #右对齐
S.splitlines([keepends]) #把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符。
S.swapcase() #大小写互换