str字符串常用方法
Posted （野生程序员）
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了str字符串常用方法相关的知识，希望对你有一定的参考价值。
字符串是编程中常用的类型，字符型在内存中是以单个形式存储的，比如name = "alex",在内存中存储的形式为["a","l","e","x"]，因此我们可以使用列表的很多功能来操作字符串，因为我开始的时候一直在想为什么字符串可以使用切片，可以有索引，开始的时候一直不明白，后来知道了Python字符串的存储形式之后才明白为什么存在这些方法。下面我们来看看字符串类型中包含那些方法：
在Python中有些方法下面有注释，这是因为这些方法使用Python自己编写的，我们知道Python中很多是直接调用C语言中的方法，看不到的那些是C语言中的方法。
1.capitalize(self)
def capitalize(self): # real signature unknown; restored from __doc__
"""
S.capitalize() -> str
首字母大写，只是第一个居首第一个首字母大写
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
"""
return ""
capitalize(self)是居首首字母大写，我们知道还有一个方法title()，下面来比较这两个方法的不同点：
>>> name = "alex is sb"
>>> name.capitalize()
\'Alex is sb\'
>>> name.title()
\'Alex Is Sb\'
从上面可以看出，capitalize(self)是居首首字母大写，其他字母不大写；而title(self)方法是所有单词的首字母都大写，这个在用的时候要知道是要求那么字母大写。
2.casefold(self)
def casefold(self): # real signature unknown; restored from __doc__
"""
S.casefold() -> str
所有首字母小写，等价于lower()
Return a version of S suitable for caseless comparisons.
"""
return ""
casefold(self)是将大写字母转化为小写，等价于lower(self),实例如下：
>>> name = "ALEX Is SB"
>>> name.casefold()
\'alex is sb\'
>>> name
\'ALEX Is SB\'
>>> name.lower()
\'alex is sb\'
3.center(self,width,fillchar=None)
def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.center(width[, fillchar]) -> str
"""center(self,width,fillchar=None)是将字符串放到中间，两边加上任意符号，默认空格"""
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""
center(self,width,fillchar=None)，美化格式，把self放到中间，指定任意长度的字符，空白处用字符填充，默认时空字符。示例如下：
>>> name = "您好"
>>> name.center(12)
\' 您好 \'
>>> name.center(12,"-")
\'-----您好-----\'
4.__format__(self,format_spec)
def __format__(self, format_spec): # real signature unknown; restored from __doc__
"""
S.__format__(format_spec) -> str
字符串的格式化
Return a formatted version of S as described by format_spec.
"""
return ""
__format__(self,format_spec)字符串进行格式化，按照我们要求的格式进行字符串格式化操作。详细可参考(http://www.cnblogs.com/nulige/p/6115793.html)
>>> tp1 = "My name is {0},and I am {1} years old,I am {2}"
>>> tp1.format("Alex","18","sb")
\'My name is Alex,and I am 18 years old,I am sb\'
>>> tp2 = "I am {1} years old,my name is {2},and I am {0}."
>>> tp2.format("sb","18","Alex")
\'I am 18 years old,my name is Alex,and I am sb.\'
这种方法也可以用在字符串的拼接上面，使用字符串的format()方法，在{}大括号中定义索引，告诉Python把哪个值传给索引位置。
5.__getattribute__(self,*args,**kwargs)
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
"""反射的时候用的"""
pass
6.__getitem__(self,*args,**kwargs)
def __getitem__(self, *args, **kwargs): # real signature unknown
""" Return self[key]. """
"""得到字符串低级个元素，等价于self[key]"""
pass
就是获取字符串中第几个位置的字符，我们知道字符串在内存中是以列表形式存储的，因此可以使用索引来获取单个字符，实例如下：
>>> name = "Alexissb"
>>> name.__getitem__(2)
\'e\'
>>> name[2]
\'e\'
字符串中索引是从0开始的，获取字符串中第几个位置的字符。
7.__getnewargs__(self,*args,**kwargs)
def __getnewargs__(self, *args, **kwargs): # real signature unknown
"""__getnewargs__是跟参数有关的"""
pass
8.__hash__(self,*args,**kwargs)
def __hash__(self, *args, **kwargs): # real signature unknown
""" Return hash(self). """
pass
9.__iter__(self,*args,**kwargs)
def __iter__(self, *args, **kwargs): # real signature unknown
""" Implement iter(self). """
pass
10.__len__(self,*args,**kwargs)
def __len__(self, *args, **kwargs): # real signature unknown
""" Return len(self). """
"""返回字符串的长度,等价与len(self)"""
pass
实例如下：
>>> name = "Alexissb"
>>> name.__len__()
8
>>> len(name)
8
11.count(self,sub,start=None,end=None)
def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.count(sub[, start[, end]]) -> int
返回在字符串中出现指定字符的个数，返回一个整数
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
"""
return 0
count(self,sub,start=None,end=None)是用来统计字符串中出现特定字符的个数，返回一个整数，实例如下：
>>> name = "Alexssbbafadgcxlsdgpssl"
>>> name.count("a")
2
>>> name.count("D")
0
统计字符串中出现指定字符的个数，当不存在的时候返回0。
12.encode(self,encoding=\'utf-8\',errors=\'strict\')
def encode(self, encoding=\'utf-8\', errors=\'strict\'): # real signature unknown; restored from __doc__
"""
S.encode(encoding=\'utf-8\', errors=\'strict\') -> bytes
编码
Encode S using the codec registered for encoding. Default encoding
is \'utf-8\'. errors may be given to set a different error
handling scheme. Default is \'strict\' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and
\'xmlcharrefreplace\' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
"""
return b""
实例如下：
>>> name = "李杰"
>>> name.encode("gbk")
b\'\\xc0\\xee\\xbd\\xdc\'
将字符串转化为"gbk"格式，机器识别的格式。
13.endswith(self,suffix,start=None,end=None)
def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.endswith(suffix[, start[, end]]) -> bool
字符串是否以指定的字符结束，endswith(self,suffix,start=None,end=None)
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
"""
return False
endswith(self,suffix,start=None,end=None)判断字符串以某个指定的字符结束，如果是，则返回布尔值True；否则返回False。
>>> name = "Alexsssbdfgedlmnopqqsstabsc"
>>> name.endswith("c")
True
>>> name.endswith("s",0,5)
True
14.expandtabs(self,tabsize=8)
def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
"""
S.expandtabs(tabsize=8) -> str
将字符串中的tab键转化为空格，默认时8个位置的空格，可以自己设置参数
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
return ""
expandtabs(self,tabsize=8)将字符串中的tab(\\t)将转化为空格，默认是转化为8个空格，可以自己设置转化为几个空格。示例如下：
>>> user = " Alex"
>>> user.expandtabs()
\' Alex\'
>>> user.expandtabs(2)
\' Alex\'
>>> user.expandtabs(0)
\'Alex\'
>>> user.expandtabs(tabsize=3)
\' Alex\'
15.find(self,sub,start=None,end=None)
def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.find(sub[, start[, end]]) -> int
查找指定字符在字符串中的位置，返回位置索引，如果查找不到，则返回-1（return -1 on failure)
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
find(self,sub,start=None,end=None)查找指定字符在字符串中的位置，如果查找不到，则返回-1(即查找字符不存在指定字符串中),示例如下：
>>> name
\'Alexsssbdfgedlmnopqqsstabsc\'
>>> name.find("s")
4
>>> name.find("s",8,len(name)-1)
20
>>> name.find("S")
-1
find(self,sub,start=None,end=None)查找这个字符第一次出现的位置索引。只查找第一个位置索引，查找失败返回-1.
16.index(self,sub,start=None,end=None)
def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.index(sub[, start[, end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
"""
return 0
index(self,sub,start=None,end=None)跟find()一样是查找指定字符在字符串中的位置索引，不同的是，如果index()查找失败，则报错。查找不到报错。 示例如下：
>>> name
\'Alexsssbdfgedlmnopqqsstabsc\'
>>> name.index("s")
4
>>> name.index("s",8,len(name)-1)
20
>>> name.index("S")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
上面可以看出，index()和find()是一样的，都是返回查找字符的位置索引，但是当index()查找不到的时候会报错。
17.format_map(self,mapping)
def format_map(self, mapping): # real signature unknown; restored from __doc__
"""
S.format_map(mapping) -> str
Return a formatted version of S, using substitutions from mapping.
The substitutions are identified by braces (\'{\' and \'}\').
"""
return ""
18.isalnum(self)
def isalnum(self): # real signature unknown; restored from __doc__
"""
S.isalnum() -> bool
判断字符串中所有的字符是否都是字符数字组成
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
"""
return False
示例如下：判断字符串中是否所有元素只有数字和字母组成，alnum是单词alphanumeric的缩写，字母数字。
>>> name.isalnum()
True
>>> nums = "2233"
>>> nums.isalnum()
True
19.isalpha()
def isalpha(self): # real signature unknown; restored from __doc__
"""
S.isalpha() -> bool
判断字符串中所有的元素是否都是字母组成
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
"""
return False
判断字符串所有字符是否都是字母alpha是单词alphabetic(字母)的缩写：
>>> nums = "2233"
>>> name.isalpha()
True
>>> nums.isalpha()
False
20.isdecimal(self)
def isdecimal(self): # real signature unknown; restored from __doc__
"""
S.isdecimal() -> bool
如果字符串中值包含十进制的数字，则返回True；否则返回布尔值False.
Return True if there are only decimal characters in S,
False otherwise.
"""
return False
isdecimal(self)判断字符串中是否只包含十进制的数字，如果是，则返回True;否则返回False。示例如下：
>>> s1 = "a122"
>>> s2 = "222"
>>> s3 = "&b#s"
>>> s1.isdecimal()
False
>>> s2.isdecimal()
True
>>> s3.isdecimal()
False
21.isdigit(self)
def isdigit(self): # real signature unknown; restored from __doc__
"""
S.isdigit() -> bool
判断字符串是否仅仅由数字组成
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
"""
return False
isdigit(self)判断字符串中是否仅仅包含数字，即由数字组成的字符串。实例如下：
>>> s1 = "a122"
>>> s2 = "222"
>>> s3 = "&b#s"
>>> s1.isdigit()
False
>>> s2.isdigit()
True
>>> s3.isdigit()
False
22.isidentifier(self)
def isidentifier(self): # real signature unknown; restored from __doc__
"""
S.isidentifier() -> bool
Return True if S is a valid identifier according
to the language definition.
Use keyword.iskeyword() to test for reserved identifiers
such as "def" and "class".
"""
return False
isidentifier(self),实例如下：
>>> s2 = "Alex"
>>> s3 = "list"
>>> s2.isidentifier()
True
>>> s3.isidentifier()
True
>>> s4 = "55"
>>> s4.isidentifier()
False
>>> s5 = "gengcx"
>>> s5.isidentifier()
True
23.islower(self)
def islower(self): # real signature unknown; restored from __doc__
"""
S.islower() -> bool
判断是否都是小写
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
"""
return False
islower(self)判断字符串是否都是小写，
>>> s1 = "Alex"
>>> s2 = "23abc"
>>> s3 = "alex"
>>> s4 = "AlexSb&&"
>>> s5 = "a%@"
>>> s1.islower()
False
>>> s2.islower()
True
>>> s3.islower()
True
>>> s4.islower()
False
>>> s5.islower()
True
24.isnumeric(self)
def isnumeric(self): # real signature unknown; restored from __doc__
"""
S.isnumeric() -> bool
Return True if there are only numeric characters in S,
False otherwise.
"""
return False
isnumeric(self)判断字符串S中是否值包含数字在里面，如果是，返回True;否则返回False.
>>> name = "Alex222"
>>> nums = "234239"
>>> num = "23se"
>>> l1 = "2.35"
>>> name.isnumeric()
False
>>> nums.isnumeric()
True
>>> num.isnumeric()
False
>>> l1.isnumeric()
False
25.isprintable(self)
def isprintable(self): # real signature unknown; restored from __doc__
"""
S.isprintable() -> bool
判断一个字符串是否里面的字符都是可以打印出来的或者字符串是空的，如果是返回True;否则返回False
Return True if all characters in S are considered
printable in repr() or S is empty, False otherwise.
"""
return False
isprintable(self)
>>> name = " Alex"
>>> name.isprintable()
False
>>> user = "Alex"
>>> user.isprintable()
True
>>> s1 = ""
>>> s1.isprintable()
True
isprintable(s1)中s1是空的字符串，但是也返回True.
26.isspace(self)
def isspace(self): # real signature unknown; restored from __doc__
"""
S.isspace() -> bool
判断字符串中是否都是空白
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
"""
return False
isspace(self)判断字符串中是否都是空白，如果是返回True;否则返回False。示例如下：
>>> s1 = " "
>>> s2 = " "
>>> s3 = "cs "
>>> s1.isspace()
True
>>> s2.isspace()
True
>>> s3.isspace()
False
27.istitle(self)
def istitle(self): # real signature unknown; restored from __doc__
"""
S.istitle() -> bool
判断字符串中所有字符是否是首字母大写形式，如果是返回True
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
"""
return False
istitle(self)判断是否首字母大写，如果是返回True;否则返回False。实例如下：
>>> s1 = "Alex is sb"
>>> s2 = "Alex Is Sb"
>>> s3 = "alex is sb"
>>> s1.istitle()
False
>>> s2.istitle()
True
>>> s3.istitle()
False
28.isupper(self)
def isupper(self): # real signature unknown; restored from __doc__
"""
S.isupper() -> bool
判断所有字母是否都是大写
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
"""
return False
isupper(self)判断字符串中所有字符是否都是大写形式：实例如下：
>>> s1 = "Alex is sb"
>>> s2 = "Alex Is Sb"
>>> s3 = "alex is sb"
>>> s4 = "ALEX IS SB"
>>> s1.isupper()
False
>>> s2.isupper()
False
>>> s3.isupper()
False
>>> s4.isupper()
True
29.join(self,iterable)
def join(self, iterable): # real signature unknown; restored from __doc__
"""
S.join(iterable) -> str
字符串的拼接，把字符串拼接到一起
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""
join(self,iterable)拼接，字符串和列表直接的拼接，有不同方式的拼接，下面来研究一下：
>>> sign = "-"
>>> name = "alex"
>>> li = ["a","l","e","x","s","b"]
>>> l1 = ""
1.字符串和字符串进行拼接，将拼接中的字符串的每一个元素与字符串中的元素进行拼接，即iterable+self+iterable+self...
>>sign.join(name)
\'a-l-e-x\'
>>> name.join("sb")
\'salexb\'
>>> name.join("issb")
\'ialexsalexsalexb\'
2.字符串和列表进行拼接，列表中的每一个元素都与字符串的元素进行拼接：
>>> sign.join(li)
\'a-l-e-x-s-b\'
>>> l1.join(li)
\'alexsb\'
其实在Python中，字符串存储的格式就是列表存储的，比如"alexsb"存储就是["a","l","e","x","s","b"]，因而字符串与列表拼接与字符串与字符串拼接是一样的。
30.ljust(self,width,fillchar=None)
def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.ljust(width[, fillchar]) -> str
固定长度，字符串左边拼接指定的字符
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
ljust(self,width,fillchar=None),固定长度，self+fillchar，实例如下：
>>> name = "alexsb"
>>> name.ljust(12,"-")
\'alexsb------\'
31.rjust(self,width,fillchar=None)
def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.rjust(width[, fillchar]) -> str
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
固定字符串长度，在字符串左侧链接指定字符，实例如下：
>>> name = "alexsb"
>>> name.rjust(12,"-")
\'------alexsb\'
32.lower(self)
def lower(self): # real signature unknown; restored from __doc__
"""
S.lower() -> str
将字符串全部转化为小写形式
Return a copy of the string S converted to lowercase.
"""
return ""
33.lstrip(self,chars=None)
def lstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.lstrip([chars]) -> str
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""